See if a time span is bigger than X

While Invoke might be the most straightforward approach, there are better options out there are easier to test for your time span. Here are two solutions that I believe are more reliable depending on how you want to actually implement this system:

Option 1: System Time Comparison

As a programmer, you have access to a variety of information provided by the operating system. This information can be accessed from the System class in the .Net framework, and can be used within your C# code very easily.

I'm not sure if you want the reward to appear after waiting 6 hours of realtime, or of the game running. (I.E. did someoone close the game and wait 6 hours before opening?) If you want this behavior, then you can simply retrieve the current time from the OS and compare it to the time you want. So at the start of whenever you want the waiting to begin, you can cache the current OS time by saving System.DateTime.Now. Then every so often (or whenever you want to check for the reward) you can compare System.DateTime.Now to the cached result.

 void CheckReward() {
     if ((System.DateTime.Now - cachedTime) >= 6) 
         GiveReward();
 }

However, I don't think you can just do a direct comparison like this because .Now returns a type DateTime. You'll have to look up how comparisons work between this type of class and extract the relevant information (the hours). Now you might have a problem if someone tries to cheat by advancing their system clock but that also becomes a useful tool for you to test if it works. However, I wouldn't recommend this method if you want to avoid cheating and need a more reliable system.

Option 2: Manually Track Time

For some cases it's better to have full control over the comparison values so that you can easily test the results without worrying about how the player might interfere on a built game. The easiest way to manually track the time spent is to either look at Time.time or Time.deltaTime. For the least amount of confusion, let's look at Time.deltaTime.

Every time a frame is rendered, the Update() function is called. Since this happens at a variable time-frame, Unity has built in deltaTime as a way to keep track of how long it's been since the last frame. If we continuously add the time from each frame to one variable, we are now keeping track of how many seconds have passed:

 void Update() {
     seconds += Time.deltaTime;
 }

Okay great, but we're looking on the scale of hours, not seconds. And what happens if our seconds get so large that we exceed the floating point maximum value? (Unlikely, but always something to worry about) Well then, let's just use a second variable called "minutes" and refresh our seconds every time we hit 60:

 void Update() {
     seconds += Time.deltaTime;
     if (seconds >= 60) {
         minutes++;
         seconds = 0.0f;
     }
 }

Great, we've pushed back our problem so now we only have to deal with minutes, and it'll take a lot longer for minutes to reach the maximum integer value. But we can do even better.

 void Update() {
     seconds += Time.deltaTime;
     if (seconds >= 60) {
         minutes++;
         seconds = 0.0f;
     }
     if (minutes >= 60) {
         hours++;
         minutes = 0;
     }
     if (hours >= 6)
         GiveReward;
 }

Now, if we want to test that our code works, we simply have to observe what happens when seconds ticks over 60. If our minutes increment, we can be pretty sure that they will count up to 60. Same for hours. If we want to test if GiveReward is called, we merely need to set our hours to 5 and minutes to 59 in the Inspector. Then we watch what happens when the seconds ticks over.

The best part about this method is that seconds, minutes, and hours are all serializable, and can be saved if you wish to continue keeping track of time across play sessions, like if someone saves the game and continues later.

Possible Optimization

A lot of people make the mistake of checking things in Update() unnecessarily. Remember that more work your code does on each frame, the slower your game will run. For example, if you know that you will only check rewards at the end of mission or something, you do the comparisons by checking Time.time instead and only then will you check if the hours are >= 6.

Another good optimization is to have the above code run in FixedUpdate instead. If you don't need frame-perfect precision and can settle for 50 times a second or however many you've set, then you can replace Time.deltaTime with Time.fixedDeltaTime (once it's in FixedUpdate). You'll be doing less work if it's run on the FixedUpdate cycle, since it won't run thousands of times if you're getting a high framerate.

If any of this was confusing you should look into learning more about how Unity and the .Net framework works. There are tons of subtle tricks to getting the most out of the engine, but thinking up broad-scale approaches like this is a critical skill in all types of programming.

you could do a Invoke and then just convert your 6hours into second. You can test this by doing 10 seconds first like

     void Start()
     {
         Invoke("GiveReward", 10);
     }
 
     void GiveReward()
     {
         //give the player reward code here
     }

 public class WaitTime : MonoBehaviour {
 
      public float rewardHour;
    
      void Start()
      {
           //start rewarding
           StartCoroutine(giveReward());
      }
      public IEnumerator giveReward()
      {
           yield return new WaitForSeconds(hourToSec(rewardHour));
           //giving rewards codes
      }
 
      private float hourToSec(float hour)
      {
           return hour * 60 * 60;
      }
 
 }