diff --git a/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.DotNet.verified.txt b/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.DotNet.verified.txt
index 1b37b6e47af..60fa2406c64 100644
--- a/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.DotNet.verified.txt
+++ b/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.DotNet.verified.txt
@@ -1183,8 +1183,11 @@ namespace Akka.Actor
         void CancelAll();
         bool IsTimerActive(object key);
         void StartPeriodicTimer(object key, object msg, System.TimeSpan interval);
+        void StartPeriodicTimer(object key, object msg, System.TimeSpan interval, Akka.Actor.IActorRef sender);
         void StartPeriodicTimer(object key, object msg, System.TimeSpan initialDelay, System.TimeSpan interval);
+        void StartPeriodicTimer(object key, object msg, System.TimeSpan initialDelay, System.TimeSpan interval, Akka.Actor.IActorRef sender);
         void StartSingleTimer(object key, object msg, System.TimeSpan timeout);
+        void StartSingleTimer(object key, object msg, System.TimeSpan timeout, Akka.Actor.IActorRef sender);
     }
     public interface IUntypedActorContext : Akka.Actor.IActorContext, Akka.Actor.IActorRefFactory, Akka.Actor.ICanWatch
     {
diff --git a/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.Net.verified.txt b/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.Net.verified.txt
index 6a336c39672..eccf3f67d9b 100644
--- a/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.Net.verified.txt
+++ b/src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.Net.verified.txt
@@ -1181,8 +1181,11 @@ namespace Akka.Actor
         void CancelAll();
         bool IsTimerActive(object key);
         void StartPeriodicTimer(object key, object msg, System.TimeSpan interval);
+        void StartPeriodicTimer(object key, object msg, System.TimeSpan interval, Akka.Actor.IActorRef sender);
         void StartPeriodicTimer(object key, object msg, System.TimeSpan initialDelay, System.TimeSpan interval);
+        void StartPeriodicTimer(object key, object msg, System.TimeSpan initialDelay, System.TimeSpan interval, Akka.Actor.IActorRef sender);
         void StartSingleTimer(object key, object msg, System.TimeSpan timeout);
+        void StartSingleTimer(object key, object msg, System.TimeSpan timeout, Akka.Actor.IActorRef sender);
     }
     public interface IUntypedActorContext : Akka.Actor.IActorContext, Akka.Actor.IActorRefFactory, Akka.Actor.ICanWatch
     {
diff --git a/src/core/Akka/Actor/Scheduler/ITimerScheduler.cs b/src/core/Akka/Actor/Scheduler/ITimerScheduler.cs
index b27bd2540b8..a8495e0dd01 100644
--- a/src/core/Akka/Actor/Scheduler/ITimerScheduler.cs
+++ b/src/core/Akka/Actor/Scheduler/ITimerScheduler.cs
@@ -35,6 +35,21 @@ public interface ITimerScheduler
         /// <param name="interval">Interval</param>
         void StartPeriodicTimer(object key, object msg, TimeSpan interval);
 
+        /// <summary>
+        /// Start a periodic timer that will send <paramref name="msg"/> to the "Self" actor at
+        /// a fixed <paramref name="interval"/>.
+        ///
+        ///Each timer has a key and if a new timer with same key is started
+        /// the previous is cancelled and it's guaranteed that a message from the
+        /// previous timer is not received, even though it might already be enqueued
+        /// in the mailbox when the new timer is started.
+        /// </summary>
+        /// <param name="key">Name of timer</param>
+        /// <param name="msg">Message to schedule</param>
+        /// <param name="interval">Interval</param>
+        /// <param name="sender">The sender override for the timer message</param>
+        void StartPeriodicTimer(object key, object msg, TimeSpan interval, IActorRef sender);
+
         /// <summary>
         /// Start a periodic timer that will send <paramref name="msg"/> to the "Self" actor at
         /// a fixed <paramref name="interval"/>.
@@ -50,6 +65,22 @@ public interface ITimerScheduler
         /// <param name="interval">Interval</param>
         void StartPeriodicTimer(object key, object msg, TimeSpan initialDelay, TimeSpan interval);
 
+        /// <summary>
+        /// Start a periodic timer that will send <paramref name="msg"/> to the "Self" actor at
+        /// a fixed <paramref name="interval"/>.
+        /// 
+        /// Each timer has a key and if a new timer with same key is started
+        /// the previous is cancelled and it's guaranteed that a message from the
+        /// previous timer is not received, even though it might already be enqueued
+        /// in the mailbox when the new timer is started.
+        /// </summary>
+        /// <param name="key">Name of timer</param>
+        /// <param name="msg">Message to schedule</param>
+        /// <param name="initialDelay">Initial delay</param>
+        /// <param name="interval">Interval</param>
+        /// <param name="sender">The sender override for the timer message</param>
+        void StartPeriodicTimer(object key, object msg, TimeSpan initialDelay, TimeSpan interval, IActorRef sender);
+
         /// <summary>
         /// Start a timer that will send <paramref name="msg"/> once to the "Self" actor after
         /// the given <paramref name="timeout"/>.
@@ -64,6 +95,21 @@ public interface ITimerScheduler
         /// <param name="timeout">Interval</param>
         void StartSingleTimer(object key, object msg, TimeSpan timeout);
 
+        /// <summary>
+        /// Start a timer that will send <paramref name="msg"/> once to the "Self" actor after
+        /// the given <paramref name="timeout"/>.
+        ///
+        /// Each timer has a key and if a new timer with same key is started
+        /// the previous is cancelled and it's guaranteed that a message from the
+        /// previous timer is not received, even though it might already be enqueued
+        /// in the mailbox when the new timer is started.
+        /// </summary>
+        /// <param name="key">Name of timer</param>
+        /// <param name="msg">Message to schedule</param>
+        /// <param name="timeout">Interval</param>
+        /// <param name="sender">The sender override for the timer message</param>
+        void StartSingleTimer(object key, object msg, TimeSpan timeout, IActorRef sender);
+
         /// <summary>
         /// Check if a timer with a given <paramref name="key"/> is active.
         /// </summary>
diff --git a/src/core/Akka/Actor/Scheduler/TimerScheduler.cs b/src/core/Akka/Actor/Scheduler/TimerScheduler.cs
index d82557a1c62..9f87efdc371 100644
--- a/src/core/Akka/Actor/Scheduler/TimerScheduler.cs
+++ b/src/core/Akka/Actor/Scheduler/TimerScheduler.cs
@@ -105,7 +105,25 @@ public TimerScheduler(IActorContext ctx)
         /// <param name="interval">Interval</param>
         public void StartPeriodicTimer(object key, object msg, TimeSpan interval)
         {
-            StartTimer(key, msg, interval, interval, true);
+            StartTimer(key, msg, interval, interval, true, ActorRefs.NoSender);
+        }
+
+        /// <summary>
+        /// Start a periodic timer that will send <paramref name="msg"/> to the "Self" actor at
+        /// a fixed <paramref name="interval"/>.
+        ///
+        /// Each timer has a key and if a new timer with same key is started
+        /// the previous is cancelled and it's guaranteed that a message from the
+        /// previous timer is not received, even though it might already be enqueued
+        /// in the mailbox when the new timer is started.
+        /// </summary>
+        /// <param name="key">Name of timer</param>
+        /// <param name="msg">Message to schedule</param>
+        /// <param name="interval">Interval</param>
+        /// <param name="sender">The sender override for the timer message</param>
+        public void StartPeriodicTimer(object key, object msg, TimeSpan interval, IActorRef sender)
+        {
+            StartTimer(key, msg, interval, interval, true, sender);
         }
 
         /// <summary>
@@ -123,7 +141,26 @@ public void StartPeriodicTimer(object key, object msg, TimeSpan interval)
         /// <param name="interval">Interval</param>
         public void StartPeriodicTimer(object key, object msg, TimeSpan initialDelay, TimeSpan interval)
         {
-            StartTimer(key, msg, interval, initialDelay, true);
+            StartTimer(key, msg, interval, initialDelay, true, ActorRefs.NoSender);
+        }
+
+        /// <summary>
+        /// Start a periodic timer that will send <paramref name="msg"/> to the "Self" actor at
+        /// a fixed <paramref name="interval"/>.
+        ///
+        /// Each timer has a key and if a new timer with same key is started
+        /// the previous is cancelled and it's guaranteed that a message from the
+        /// previous timer is not received, even though it might already be enqueued
+        /// in the mailbox when the new timer is started.
+        /// </summary>
+        /// <param name="key">Name of timer</param>
+        /// <param name="msg">Message to schedule</param>
+        /// <param name="initialDelay">Initial delay</param>
+        /// <param name="interval">Interval</param>
+        /// <param name="sender">The sender override for the timer message</param>
+        public void StartPeriodicTimer(object key, object msg, TimeSpan initialDelay, TimeSpan interval, IActorRef sender)
+        {
+            StartTimer(key, msg, interval, initialDelay, true, sender);
         }
 
         /// <summary>
@@ -140,7 +177,25 @@ public void StartPeriodicTimer(object key, object msg, TimeSpan initialDelay, Ti
         /// <param name="timeout">Interval</param>
         public void StartSingleTimer(object key, object msg, TimeSpan timeout)
         {
-            StartTimer(key, msg, timeout, TimeSpan.Zero, false);
+            StartTimer(key, msg, timeout, TimeSpan.Zero, false, ActorRefs.NoSender);
+        }
+
+        /// <summary>
+        /// Start a timer that will send <paramref name="msg"/> once to the "Self" actor after
+        /// the given <paramref name="timeout"/>.
+        ///
+        /// Each timer has a key and if a new timer with same key is started
+        /// the previous is cancelled and it's guaranteed that a message from the
+        /// previous timer is not received, even though it might already be enqueued
+        /// in the mailbox when the new timer is started.
+        /// </summary>
+        /// <param name="key">Name of timer</param>
+        /// <param name="msg">Message to schedule</param>
+        /// <param name="timeout">Interval</param>
+        /// <param name="sender">The sender override for the timer message</param>
+        public void StartSingleTimer(object key, object msg, TimeSpan timeout, IActorRef sender)
+        {
+            StartTimer(key, msg, timeout, TimeSpan.Zero, false, sender);
         }
 
         /// <summary>
@@ -195,7 +250,7 @@ private void CancelTimer(Timer timer)
         }
 
 
-        private void StartTimer(object key, object msg, TimeSpan timeout, TimeSpan initialDelay, bool repeat)
+        private void StartTimer(object key, object msg, TimeSpan timeout, TimeSpan initialDelay, bool repeat, IActorRef sender)
         {
             if (_timers.TryGetValue(key, out var timer))
                 CancelTimer(timer);
@@ -210,9 +265,9 @@ private void StartTimer(object key, object msg, TimeSpan timeout, TimeSpan initi
 
             ICancelable task;
             if (repeat)
-                task = _ctx.System.Scheduler.ScheduleTellRepeatedlyCancelable(initialDelay, timeout, _ctx.Self, timerMsg, ActorRefs.NoSender);
+                task = _ctx.System.Scheduler.ScheduleTellRepeatedlyCancelable(initialDelay, timeout, _ctx.Self, timerMsg, sender);
             else
-                task = _ctx.System.Scheduler.ScheduleTellOnceCancelable(timeout, _ctx.Self, timerMsg, ActorRefs.NoSender);
+                task = _ctx.System.Scheduler.ScheduleTellOnceCancelable(timeout, _ctx.Self, timerMsg, sender);
 
             var nextTimer = new Timer(key, msg, repeat, nextGen, task);