diff --git a/src/move.c b/src/move.c
index a560030..b2b8486 100644
--- a/src/move.c
+++ b/src/move.c
@@ -2457,22 +2457,27 @@
 	beginline(BL_SOL | BL_FIX);
     curwin->w_valid &= ~(VALID_WCOL|VALID_WROW|VALID_VIRTCOL);
 
-    /*
-     * Avoid the screen jumping up and down when 'scrolloff' is non-zero.
-     * But make sure we scroll at least one line (happens with mix of long
-     * wrapping lines and non-wrapping line).
-     */
-    if (retval == OK && dir == FORWARD && check_top_offset())
+    if (retval == OK && dir == FORWARD)
     {
-	scroll_cursor_top(1, FALSE);
-	if (curwin->w_topline <= old_topline
-				  && old_topline < curbuf->b_ml.ml_line_count)
+	// Avoid the screen jumping up and down when 'scrolloff' is non-zero.
+	// But make sure we scroll at least one line (happens with mix of long
+	// wrapping lines and non-wrapping line).
+	if (check_top_offset())
 	{
-	    curwin->w_topline = old_topline + 1;
+	    scroll_cursor_top(1, FALSE);
+	    if (curwin->w_topline <= old_topline
+				  && old_topline < curbuf->b_ml.ml_line_count)
+	    {
+		curwin->w_topline = old_topline + 1;
 #ifdef FEAT_FOLDING
+		(void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
+#endif
+	    }
+	}
+#ifdef FEAT_FOLDING
+	else if (curwin->w_botline > curbuf->b_ml.ml_line_count)
 	    (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
 #endif
-	}
     }
 
     redraw_later(VALID);
diff --git a/src/testdir/test_fold.vim b/src/testdir/test_fold.vim
index de66883..df4b12c 100644
--- a/src/testdir/test_fold.vim
+++ b/src/testdir/test_fold.vim
@@ -1,5 +1,7 @@
 " Test for folding
 
+source view_util.vim
+
 func PrepIndent(arg)
   return [a:arg] + repeat(["\t".a:arg], 5)
 endfu
@@ -648,3 +650,27 @@
   endtry
   call assert_match('E492:', a)
 endfunc
+
+func Test_fold_last_line_with_pagedown()
+  enew!
+  set fdm=manual
+
+  let expect = '+-- 11 lines: 9---'
+  let content = range(1,19)
+  call append(0, content)
+  normal dd9G
+  normal zfG
+  normal zt
+  call assert_equal('9', getline(foldclosed('.')))
+  call assert_equal('19', getline(foldclosedend('.')))
+  call assert_equal(expect, ScreenLines(1, len(expect))[0])
+  call feedkeys("\<C-F>", 'xt')
+  call assert_equal(expect, ScreenLines(1, len(expect))[0])
+  call feedkeys("\<C-F>", 'xt')
+  call assert_equal(expect, ScreenLines(1, len(expect))[0])
+  call feedkeys("\<C-B>\<C-F>\<C-F>", 'xt')
+  call assert_equal(expect, ScreenLines(1, len(expect))[0])
+
+  set fdm&
+  enew!
+endfunc
diff --git a/src/version.c b/src/version.c
index de6f550..6b422e6 100644
--- a/src/version.c
+++ b/src/version.c
@@ -790,6 +790,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    174,
+/**/
     173,
 /**/
     172,
