diff --git a/app/playlists.py b/app/playlists.py
index 664eb56..aba5569 100644
--- a/app/playlists.py
+++ b/app/playlists.py
@@ -67,6 +67,7 @@ class PlaylistTab(QTableWidget):
     # Qt.UserRoles
     ROW_METADATA = Qt.UserRole
     CONTENT_OBJECT = Qt.UserRole + 1
+    ROW_DURATION = Qt.UserRole + 2
 
     def __init__(self, musicmuster: QMainWindow, session: Session,
                  playlist_id: int, *args, **kwargs):
@@ -358,6 +359,7 @@ class PlaylistTab(QTableWidget):
         duration_item: QTableWidgetItem = QTableWidgetItem(
             helpers.ms_to_mmss(track.duration)
         )
+        self._set_row_duration(row, track.duration)
         self.setItem(row, self.COL_DURATION, duration_item)
 
         last_playtime: Optional[datetime] = Playdates.last_played(
@@ -713,12 +715,6 @@ class PlaylistTab(QTableWidget):
         # For unplayed tracks, if there's a 'current' or 'next'
         # track marked, populate start times from then onwards. A note
         # with a start time will reset the next track start time.
-        if current_row and next_row:
-            start_times_row = min(current_row, next_row)
-        else:
-            start_times_row = current_row or next_row
-        if not start_times_row:
-            start_times_row = 0
 
         # Cycle through all rows
         for row in range(self.rowCount()):
@@ -778,8 +774,8 @@ class PlaylistTab(QTableWidget):
                     last_played_str)
 
                 # Calculate next_start_time
-                next_start_time = self._calculate_track_end_time(
-                    track, self.current_track_start_time)
+                next_start_time = self._calculate_row_end_time(
+                    row, self.current_track_start_time)
 
                 # Set end time
                 self._set_row_end_time(row, next_start_time)
@@ -795,8 +791,9 @@ class PlaylistTab(QTableWidget):
             # Render next track
             if row == next_row:
                 # if there's a track playing, set start time from that
-                if current_row:
-                    start_time = self.current_track_start_time
+                if current_row is not None:
+                        start_time = self._calculate_row_end_time(
+                            current_row, self.current_track_start_time)
                 else:
                     # No current track to base from, but don't change
                     # time if it's already set
@@ -806,8 +803,7 @@ class PlaylistTab(QTableWidget):
                 self._set_row_start_time(row, start_time)
 
                 # Set end time
-                next_start_time = self._calculate_track_end_time(
-                    track, start_time)
+                next_start_time = self._calculate_row_end_time(row, start_time)
                 self._set_row_end_time(row, next_start_time)
 
                 # Set colour
@@ -829,10 +825,10 @@ class PlaylistTab(QTableWidget):
                     self._set_row_not_bold(row)
                 else:
                     # Set start/end times as we haven't played it yet
-                    if next_start_time and row >= start_times_row:
+                    if next_start_time:
                         self._set_row_start_time(row, next_start_time)
-                        next_start_time = self._calculate_track_end_time(
-                            track, next_start_time)
+                        next_start_time = self._calculate_row_end_time(
+                            row, next_start_time)
                         # Set end time
                         self._set_row_end_time(row, next_start_time)
                     else:
@@ -868,18 +864,14 @@ class PlaylistTab(QTableWidget):
             track: Tracks = self._get_row_track_object(row, session)
             open_in_audacity(track.path)
 
-    @staticmethod
-    def _calculate_track_end_time(
-            track: Tracks, start: Optional[datetime]) -> Optional[datetime]:
-        """Return this track's end time given its start time"""
+    def _calculate_row_end_time(self, row, start: Optional[datetime]) \
+            -> Optional[datetime]:
+        """Return this row's end time given its start time"""
 
         if start is None:
             return None
-        if track is None:
-            DEBUG("_calculate_next_start_time() called with track=None")
-            return None
 
-        duration = track.duration
+        duration = self._get_row_duration(row)
         return start + timedelta(milliseconds=duration)
 
     def _context_menu(self, pos):  # review
@@ -1141,6 +1133,14 @@ class PlaylistTab(QTableWidget):
 
         return self._meta_search(RowMeta.NOTE, one=False)
 
+    def _get_row_duration(self, row: int) -> int:
+        """Return duration associated with this row"""
+
+        try:
+            return self.item(row, self.COL_USERDATA).data(self.ROW_DURATION)
+        except:
+            return 0
+
     def _get_row_end_time(self, row) -> Optional[datetime]:
         """
         Return row end time as string
@@ -1551,6 +1551,13 @@ class PlaylistTab(QTableWidget):
         self.item(row, self.COL_USERDATA).setData(
             self.CONTENT_OBJECT, object_id)
 
+    def _set_row_duration(self, row: int, ms: int) -> None:
+        """Set duration of this row in milliseconds"""
+
+        assert self.item(row, self.COL_USERDATA)
+
+        self.item(row, self.COL_USERDATA).setData(self.ROW_DURATION, ms)
+
     def _set_row_end_time(self, row: int, time: Optional[datetime]) -> None:
         """Set passed row end time to passed time"""