diff --git a/src/core/lwt.mli b/src/core/lwt.mli
index 9c9c2d002..4d8ad6dd6 100644
--- a/src/core/lwt.mli
+++ b/src/core/lwt.mli
@@ -1836,9 +1836,6 @@ val pause : unit -> unit t
     Putting the rest of your computation into a callback of [Lwt.pause ()]
     creates a “yield” that gives other callbacks a chance to run first.
 
-    To wait for one complete iteration of the main loop you need to wait for
-    [Lwt.pause () >>= Lwt.pause]
-
     For example, to break up a long-running computation, allowing I/O to be
     handled between chunks:
 
diff --git a/src/unix/lwt_main.ml b/src/unix/lwt_main.ml
index 17ea3c5a1..ca1f68f19 100644
--- a/src/unix/lwt_main.ml
+++ b/src/unix/lwt_main.ml
@@ -16,12 +16,10 @@ open Lwt.Infix
 
 let enter_iter_hooks = Lwt_sequence.create ()
 let leave_iter_hooks = Lwt_sequence.create ()
-let yielded = Lwt_sequence.create ()
 
-let yield () = (Lwt.add_task_r [@ocaml.warning "-3"]) yielded
+let yield () = Lwt.pause ()
 
 let abandon_yielded_and_paused () =
-  Lwt_sequence.clear yielded;
   Lwt.abandon_paused ()
 
 let run p =
@@ -34,20 +32,12 @@ let run p =
       Lwt_sequence.iter_l (fun f -> f ()) enter_iter_hooks;
 
       (* Do the main loop call. *)
-      let should_block_waiting_for_io =
-        Lwt.paused_count () = 0 && Lwt_sequence.is_empty yielded in
+      let should_block_waiting_for_io = Lwt.paused_count () = 0 in
       Lwt_engine.iter should_block_waiting_for_io;
 
       (* Fulfill paused promises. *)
       Lwt.wakeup_paused ();
 
-      (* Fulfill yield promises. *)
-      if not (Lwt_sequence.is_empty yielded) then begin
-        let tmp = Lwt_sequence.create () in
-        Lwt_sequence.transfer_r yielded tmp;
-        Lwt_sequence.iter_l (fun resolver -> Lwt.wakeup resolver ()) tmp
-      end;
-
       (* Call leave hooks. *)
       Lwt_sequence.iter_l (fun f -> f ()) leave_iter_hooks;
 
diff --git a/src/unix/lwt_main.mli b/src/unix/lwt_main.mli
index 0d5c6b3dc..9e33dd9a3 100644
--- a/src/unix/lwt_main.mli
+++ b/src/unix/lwt_main.mli
@@ -49,14 +49,9 @@ val yield : unit -> unit Lwt.t [@@deprecated "Use Lwt.pause instead"]
 
       @deprecated Since 5.5.0 [yield] is deprecated in favor of the more general
       {!Lwt.pause} in order to avoid discrepancies in resolution (see below) and
-      stay compatible with other execution environments such as js_of_ocaml.
+      stay compatible with other execution environments such as js_of_ocaml. *)
 
-      Currently, paused promises are resolved more frequently than yielded promises.
-      The difference is unintended but existing applications could depend on it.
-      Unifying the two pools of promises into one in the future would eliminate
-      possible discrepancies and simplify the code. *)
-
-val abandon_yielded_and_paused : unit -> unit
+val abandon_yielded_and_paused : unit -> unit [@@deprecated "Use Lwt.abandon_paused instead"]
 (** Causes promises created with {!Lwt.pause} and {!Lwt_main.yield} to remain
     forever pending.
 
@@ -64,7 +59,10 @@ val abandon_yielded_and_paused : unit -> unit
     Once [yield] is phased out, this function will be deprecated as well.
 
     This is meant for use with {!Lwt_unix.fork}, as a way to “abandon” more
-    promise chains that are pending in your process. *)
+    promise chains that are pending in your process.
+
+    @deprecated Since 5.5.1 [abandon_yielded_and_paused] is deprecated in favour
+    of [Lwt.abandon_paused]. *)
 
 
 
diff --git a/src/unix/lwt_unix.cppo.ml b/src/unix/lwt_unix.cppo.ml
index eda06efdf..8d1fa7f31 100644
--- a/src/unix/lwt_unix.cppo.ml
+++ b/src/unix/lwt_unix.cppo.ml
@@ -123,7 +123,7 @@ let sleep delay =
   Lwt.on_cancel waiter (fun () -> Lwt_engine.stop_event ev);
   waiter
 
-let yield = (Lwt_main.yield [@warning "-3"])
+let yield = Lwt.pause
 
 let auto_yield timeout =
   let limit = ref (Unix.gettimeofday () +. timeout) in