diff --git a/src/aura_engine/core/channels.py b/src/aura_engine/core/channels.py
index ee087b1c83814ebfd5ea2cba4163fae49995efd1..fae675751d5afd9036987e018827f583d83248db 100644
--- a/src/aura_engine/core/channels.py
+++ b/src/aura_engine/core/channels.py
@@ -445,7 +445,7 @@ class StreamChannel(GenericChannel):
 
         """
         if timeout is None:
-            timeout = 0
+            timeout = 10
 
         self.logger.debug(SU.pink(f"Loading stream '{uri}'"))
 
@@ -453,16 +453,12 @@ class StreamChannel(GenericChannel):
         self.set_url(uri)
         self.start()
 
-        retry_until = SU.timestamp() + timeout
-        retry_delay = self.config.scheduler.input_stream.retry_delay
-        retries = 0
-
+        timeout_time = SU.timestamp() + timeout
         while not self.is_ready(uri):
-            if SU.timestamp() > retry_until:
-                msg = f"Stream connection failed after {retries} retries in {timeout} seconds"
+            if SU.timestamp() > timeout_time:
+                msg = f"Load stream {uri} timed out"
                 raise LoadSourceException(msg)
-            time.sleep(retry_delay)
-            retries += 1
+            time.sleep(1)
 
         response = super().load(metadata)
         return response
diff --git a/src/aura_engine/engine.py b/src/aura_engine/engine.py
index 7bad0e934134aba10c7ce207e447392ba427327a..94906cc687066b8214896b0a8964e7f68cdbeab1 100644
--- a/src/aura_engine/engine.py
+++ b/src/aura_engine/engine.py
@@ -329,13 +329,7 @@ class Player:
             item.play.set_loading(chosen_channel)
             self.logger.info(SU.pink(msg))
 
-        timeout = item.playlist.timeslot.start - SU.timestamp()
-        it = item
-        while it is not None:
-            timeout += it.duration
-            it = it.prev
-
-        is_ready = item.play.channel.load(uri, timeout=timeout, metadata=metadata)
+        is_ready = item.play.channel.load(uri, metadata=metadata)
 
         if is_ready:
             item.play.set_ready()
diff --git a/src/aura_engine/scheduling/domain.py b/src/aura_engine/scheduling/domain.py
index 481994e511392f290d9fde888ddbc8df1cf6e31e..a3f155ed3981eee96c4d10ee6009cf640263e2df 100644
--- a/src/aura_engine/scheduling/domain.py
+++ b/src/aura_engine/scheduling/domain.py
@@ -538,7 +538,7 @@ class PlayState:
         READY = "ready"
         PLAYING = "playing"
         DONE = "done"
-        FAILED = "failed"
+        TIMEOUT = "timeout"
 
     state: PlayStateType
     play_start: float
diff --git a/src/aura_engine/scheduling/scheduler.py b/src/aura_engine/scheduling/scheduler.py
index c2cabf5f8fbc0a66f0f9eb761487b3a7b83331be..cbe6bedc87e0e6f62207af8862b93dd0dbeae169 100644
--- a/src/aura_engine/scheduling/scheduler.py
+++ b/src/aura_engine/scheduling/scheduler.py
@@ -183,7 +183,7 @@ class PlayCommand(EngineExecutor):
         last_item: PlaylistItem = items[-1]
         if not last_item.play.is_ready():
             msg = f"Items didn't reach 'ready' state during preloading (Items: {items_str})"
-            last_item.play.state = PlayState.PlayStateType.FAILED
+            last_item.play.state = PlayState.PlayStateType.TIMEOUT
             self.logger.warning(SU.red(msg))
 
     def do_play(self, items: list[PlaylistItem]):
@@ -193,8 +193,7 @@ class PlayCommand(EngineExecutor):
         Args:
             items ([PlaylistItem]): The set of playlist items to be played.
         """
-        retry_interval = 1
-        log_interval = 30
+        log_interval = 3
         last_log = 0
 
         items_str = ResourceUtil.get_items_string(items)
@@ -204,13 +203,12 @@ class PlayCommand(EngineExecutor):
         while not last_item.play.is_ready():
             now = SU.timestamp()
             if now - last_log > log_interval:
-                msg = f"PLAY: Item(s) not yet ready to be played" f" (Items: {items_str})"
-                self.logger.critical(SU.red(msg))
+                self.logger.critical(SU.red(f"PLAY: Item(s) not yet ready ({items_str})"))
                 last_log = now
-            if last_item.play.state == PlayState.PlayStateType.FAILED:
-                self.logger.info("PLAY: Preloading failed - skipping play")
-                return
-            time.sleep(retry_interval)
+            if last_item.play.state == PlayState.PlayStateType.TIMEOUT:
+                self.logger.warn(SU.red("PLAY: Preloading timed out."))
+                break
+            time.sleep(1)
         self.engine.player.play(items[0], engine.Player.TransitionType.FADE)
         timetable_renderer: utils.TimetableRenderer = self.engine.scheduler.timetable_renderer
         self.logger.info(timetable_renderer.get_ascii_timeslots())