diff --git a/freqtrade/worker.py b/freqtrade/worker.py
index a407de0d7..27f067b07 100755
--- a/freqtrade/worker.py
+++ b/freqtrade/worker.py
@@ -150,14 +150,20 @@ class Worker:
         if timeframe:
             next_tf = timeframe_to_next_date(timeframe)
             # Maximum throttling should be until new candle arrives
-            # Offset of 0.2s is added to ensure a new candle has been issued.
-            next_tf_with_offset = next_tf.timestamp() - time.time() + timeframe_offset
+            # Offset is added to ensure a new candle has been issued.
+            next_tft = next_tf.timestamp() - time.time()
+            next_tf_with_offset = next_tft + timeframe_offset
+            if next_tft < sleep_duration and sleep_duration < next_tf_with_offset:
+                # Avoid hitting a new loop between the new candle and the candle with offset
+                sleep_duration = next_tf_with_offset
             sleep_duration = min(sleep_duration, next_tf_with_offset)
         sleep_duration = max(sleep_duration, 0.0)
         # next_iter = datetime.now(timezone.utc) + timedelta(seconds=sleep_duration)
 
         logger.debug(f"Throttling with '{func.__name__}()': sleep for {sleep_duration:.2f} s, "
-                     f"last iteration took {time_passed:.2f} s.")
+                     f"last iteration took {time_passed:.2f} s."
+                     #  f"next: {next_iter}"
+                     )
         self._sleep(sleep_duration)
         return result
 
diff --git a/tests/test_worker.py b/tests/test_worker.py
index ae511852f..88d495e13 100644
--- a/tests/test_worker.py
+++ b/tests/test_worker.py
@@ -113,6 +113,16 @@ def test_throttle_sleep_time(mocker, default_conf, caplog) -> None:
         # 300 (5m) - 60 (1m - see set time above) - 5 (duration of throttled_func) = 235
         assert 235.2 < sleep_mock.call_args[0][0] < 235.6
 
+        t.move_to("2022-09-01 05:04:51 +00:00")
+        sleep_mock.reset_mock()
+        # Offset of 5s, so we hit the sweet-spot between "candle" and "candle offset"
+        # Which should not get a throttle iteration to avoid late candle fetching
+        assert worker._throttle(throttled_func, throttle_secs=10, timeframe='5m',
+                                timeframe_offset=5, x=1.2) == 42
+        assert sleep_mock.call_count == 1
+        # Time is slightly bigger than throttle secs due to the high timeframe offset.
+        assert 11.1 < sleep_mock.call_args[0][0] < 13.2
+
 
 def test_throttle_with_assets(mocker, default_conf) -> None:
     def throttled_func(nb_assets=-1):