diff --git a/arch/sim/src/sim/up_blocktask.c b/arch/sim/src/sim/up_blocktask.c
index 8edf230e61..ab690e66e9 100644
--- a/arch/sim/src/sim/up_blocktask.c
+++ b/arch/sim/src/sim/up_blocktask.c
@@ -134,18 +134,6 @@ void up_block_task(struct tcb_s *tcb, tstate_t task_state)
           rtcb = this_task();
           sinfo("New Active Task TCB=%p\n", rtcb);
 
-          /* The way that we handle signals in the simulation is kind of
-           * a kludge.  This would be unsafe in a truly multi-threaded,
-           * interrupt driven environment.
-           */
-
-          if (rtcb->xcp.sigdeliver)
-            {
-              sinfo("Delivering signals TCB=%p\n", rtcb);
-              ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
-              rtcb->xcp.sigdeliver = NULL;
-            }
-
           /* Reset scheduler parameters */
 
           nxsched_resume_scheduler(rtcb);
@@ -154,5 +142,20 @@ void up_block_task(struct tcb_s *tcb, tstate_t task_state)
 
           up_longjmp(rtcb->xcp.regs, 1);
         }
+      else
+        {
+          /* The way that we handle signals in the simulation is kind of
+           * a kludge.  This would be unsafe in a truly multi-threaded,
+           * interrupt driven environment.
+           */
+
+          rtcb = this_task();
+          if (rtcb->xcp.sigdeliver)
+            {
+              sinfo("Delivering signals TCB=%p\n", rtcb);
+              ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
+              rtcb->xcp.sigdeliver = NULL;
+            }
+        }
     }
 }
diff --git a/arch/sim/src/sim/up_exit.c b/arch/sim/src/sim/up_exit.c
index 55c189ebe8..73d7e185f0 100644
--- a/arch/sim/src/sim/up_exit.c
+++ b/arch/sim/src/sim/up_exit.c
@@ -92,18 +92,6 @@ void up_exit(int status)
 
   nxsched_resume_scheduler(tcb);
 
-  /* The way that we handle signals in the simulation is kind of
-   * a kludge.  This would be unsafe in a truly multi-threaded, interrupt
-   * driven environment.
-   */
-
-  if (tcb->xcp.sigdeliver)
-    {
-      sinfo("Delivering signals TCB=%p\n", tcb);
-      ((sig_deliver_t)tcb->xcp.sigdeliver)(tcb);
-      tcb->xcp.sigdeliver = NULL;
-    }
-
   /* Then switch contexts */
 
   up_longjmp(tcb->xcp.regs, 1);
diff --git a/arch/sim/src/sim/up_releasepending.c b/arch/sim/src/sim/up_releasepending.c
index 77210d215e..88e75b445d 100644
--- a/arch/sim/src/sim/up_releasepending.c
+++ b/arch/sim/src/sim/up_releasepending.c
@@ -103,18 +103,6 @@ void up_release_pending(void)
           rtcb = this_task();
           sinfo("New Active Task TCB=%p\n", rtcb);
 
-          /* The way that we handle signals in the simulation is kind of
-           * a kludge.  This would be unsafe in a truly multi-threaded,
-           * interrupt driven environment.
-           */
-
-          if (rtcb->xcp.sigdeliver)
-            {
-              sinfo("Delivering signals TCB=%p\n", rtcb);
-              ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
-              rtcb->xcp.sigdeliver = NULL;
-            }
-
           /* Update scheduler parameters */
 
           nxsched_resume_scheduler(rtcb);
@@ -123,5 +111,20 @@ void up_release_pending(void)
 
           up_longjmp(rtcb->xcp.regs, 1);
         }
+      else
+        {
+          /* The way that we handle signals in the simulation is kind of
+           * a kludge.  This would be unsafe in a truly multi-threaded,
+           * interrupt driven environment.
+           */
+
+          rtcb = this_task();
+          if (rtcb->xcp.sigdeliver)
+            {
+              sinfo("Delivering signals TCB=%p\n", rtcb);
+              ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
+              rtcb->xcp.sigdeliver = NULL;
+            }
+        }
     }
 }
diff --git a/arch/sim/src/sim/up_reprioritizertr.c b/arch/sim/src/sim/up_reprioritizertr.c
index 7d529d2a6f..c3b69d08f3 100644
--- a/arch/sim/src/sim/up_reprioritizertr.c
+++ b/arch/sim/src/sim/up_reprioritizertr.c
@@ -158,18 +158,6 @@ void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
               rtcb = this_task();
               sinfo("New Active Task TCB=%p\n", rtcb);
 
-              /* The way that we handle signals in the simulation is kind of
-               * a kludge.  This would be unsafe in a truly multi-threaded,
-               * interrupt driven environment.
-               */
-
-              if (rtcb->xcp.sigdeliver)
-                {
-                  sinfo("Delivering signals TCB=%p\n", rtcb);
-                  ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
-                  rtcb->xcp.sigdeliver = NULL;
-                }
-
               /* Update scheduler parameters */
 
               nxsched_resume_scheduler(rtcb);
@@ -178,6 +166,21 @@ void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority)
 
               up_longjmp(rtcb->xcp.regs, 1);
             }
+          else
+            {
+              /* The way that we handle signals in the simulation is kind of
+               * a kludge.  This would be unsafe in a truly multi-threaded,
+               * interrupt driven environment.
+               */
+
+              rtcb = this_task();
+              if (rtcb->xcp.sigdeliver)
+                {
+                  sinfo("Delivering signals TCB=%p\n", rtcb);
+                  ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
+                  rtcb->xcp.sigdeliver = NULL;
+                }
+            }
         }
     }
 }
diff --git a/arch/sim/src/sim/up_unblocktask.c b/arch/sim/src/sim/up_unblocktask.c
index 341608c2ac..07424c7bf9 100644
--- a/arch/sim/src/sim/up_unblocktask.c
+++ b/arch/sim/src/sim/up_unblocktask.c
@@ -136,18 +136,6 @@ void up_unblock_task(FAR struct tcb_s *tcb)
           rtcb = this_task();
           sinfo("New Active Task TCB=%p\n", rtcb);
 
-          /* The way that we handle signals in the simulation is kind of
-           * a kludge.  This would be unsafe in a truly multi-threaded,
-           * interrupt driven environment.
-           */
-
-          if (rtcb->xcp.sigdeliver)
-            {
-              sinfo("Delivering signals TCB=%p\n", rtcb);
-              ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
-              rtcb->xcp.sigdeliver = NULL;
-            }
-
           /* Update scheduler parameters */
 
           nxsched_resume_scheduler(rtcb);
@@ -156,5 +144,20 @@ void up_unblock_task(FAR struct tcb_s *tcb)
 
           up_longjmp(rtcb->xcp.regs, 1);
         }
+      else
+        {
+          /* The way that we handle signals in the simulation is kind of
+           * a kludge.  This would be unsafe in a truly multi-threaded,
+           * interrupt driven environment.
+           */
+
+          rtcb = this_task();
+          if (rtcb->xcp.sigdeliver)
+            {
+              sinfo("Delivering signals TCB=%p\n", rtcb);
+              ((sig_deliver_t)rtcb->xcp.sigdeliver)(rtcb);
+              rtcb->xcp.sigdeliver = NULL;
+            }
+        }
     }
 }