diff --git a/src/drawline.c b/src/drawline.c
index 747a1e3..679e4ca 100644
--- a/src/drawline.c
+++ b/src/drawline.c
@@ -945,8 +945,7 @@
     if (wp->w_p_cul && lnum == wp->w_cursor.lnum)
     {
 	// Do not show the cursor line in the text when Visual mode is active,
-	// because it's not clear what is selected then.  Do update
-	// w_last_cursorline.
+	// because it's not clear what is selected then.
 	if (!(wp == curwin && VIsual_active)
 					 && wp->w_p_culopt_flags != CULOPT_NBR)
 	{
@@ -971,18 +970,14 @@
 		else
 # endif
 		    line_attr = cul_attr;
-		wp->w_last_cursorline = wp->w_cursor.lnum;
 	    }
 	    else
 	    {
 		line_attr_save = line_attr;
-		wp->w_last_cursorline = 0;
 		margin_columns_win(wp, &left_curline_col, &right_curline_col);
 	    }
 	    area_highlighting = TRUE;
 	}
-	else
-	    wp->w_last_cursorline = wp->w_cursor.lnum;
     }
 #endif
 
diff --git a/src/drawscreen.c b/src/drawscreen.c
index a562c4d..a902397 100644
--- a/src/drawscreen.c
+++ b/src/drawscreen.c
@@ -1468,9 +1468,6 @@
 # define DID_FOLD 3	// updated a folded line
     int		did_update = DID_NONE;
     linenr_T	syntax_last_parsed = 0;		// last parsed text line
-    // remember the current w_last_cursorline, it changes when drawing the new
-    // cursor line
-    linenr_T	last_cursorline = wp->w_last_cursorline;
 #endif
     linenr_T	mod_top = 0;
     linenr_T	mod_bot = 0;
@@ -2245,8 +2242,8 @@
 #endif
 				))))
 #ifdef FEAT_SYN_HL
-		|| (wp->w_p_cul && (lnum == wp->w_cursor.lnum
-						   || lnum == last_cursorline))
+		|| (wp->w_p_cul && lnum == wp->w_cursor.lnum)
+		|| lnum == wp->w_last_cursorline
 #endif
 				)
 	{
@@ -2551,6 +2548,12 @@
 
     // End of loop over all window lines.
 
+#ifdef FEAT_SYN_HL
+    // Now that the window has been redrawn with the old and new cursor line,
+    // update w_last_cursorline.
+    wp->w_last_cursorline = wp->w_p_cul ? wp->w_cursor.lnum : 0;
+#endif
+
 #ifdef FEAT_VTP
     // Rewrite the character at the end of the screen line.
     // See the version that was fixed.
diff --git a/src/move.c b/src/move.c
index 1c88e6e..571ec8c 100644
--- a/src/move.c
+++ b/src/move.c
@@ -115,14 +115,6 @@
     set_empty_rows(wp, done);
 }
 
-#ifdef FEAT_SYN_HL
-    void
-reset_cursorline(void)
-{
-    curwin->w_last_cursorline = 0;
-}
-#endif
-
 /*
  * Redraw when w_cline_row changes and 'relativenumber' or 'cursorline' is
  * set.
@@ -138,24 +130,8 @@
 	    && (wp->w_valid & VALID_CROW) == 0
 	    && !pum_visible())
     {
-	if (wp->w_p_rnu)
-	    // win_line() will redraw the number column only.
-	    redraw_win_later(wp, VALID);
-#ifdef FEAT_SYN_HL
-	if (wp->w_p_cul)
-	{
-	    if (wp->w_redr_type <= VALID && wp->w_last_cursorline != 0)
-	    {
-		// "w_last_cursorline" may be outdated, worst case we redraw
-		// too much.  This is optimized for moving the cursor around in
-		// the current window.
-		redrawWinline(wp, wp->w_last_cursorline);
-		redrawWinline(wp, wp->w_cursor.lnum);
-	    }
-	    else
-		redraw_win_later(wp, SOME_VALID);
-	}
-#endif
+	// win_line() will redraw the number column and cursorline only.
+	redraw_win_later(wp, VALID);
     }
 }
 
diff --git a/src/option.c b/src/option.c
index 9369066..71b71ba 100644
--- a/src/option.c
+++ b/src/option.c
@@ -2782,11 +2782,6 @@
 	p_lrm = !p_lnr;
 #endif
 
-#ifdef FEAT_SYN_HL
-    else if ((int *)varp == &curwin->w_p_cul && !value && old_value)
-	reset_cursorline();
-#endif
-
 #ifdef FEAT_PERSISTENT_UNDO
     // 'undofile'
     else if ((int *)varp == &curbuf->b_p_udf || (int *)varp == &p_udf)
diff --git a/src/proto/move.pro b/src/proto/move.pro
index d78623a..e6a0601 100644
--- a/src/proto/move.pro
+++ b/src/proto/move.pro
@@ -1,5 +1,4 @@
 /* move.c */
-void reset_cursorline(void);
 void redraw_for_cursorline(win_T *wp);
 void update_topline_redraw(void);
 void update_topline(void);
diff --git a/src/version.c b/src/version.c
index 695ddaf..ad4f3c8 100644
--- a/src/version.c
+++ b/src/version.c
@@ -751,6 +751,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    4614,
+/**/
     4613,
 /**/
     4612,
