diff --git a/src/Discord.Net.Core/DiscordConfig.cs b/src/Discord.Net.Core/DiscordConfig.cs
index 0945a77b6..51970a781 100644
--- a/src/Discord.Net.Core/DiscordConfig.cs
+++ b/src/Discord.Net.Core/DiscordConfig.cs
@@ -152,5 +152,23 @@ namespace Discord
         ///     The currently set <see cref="RateLimitPrecision"/>.
         /// </returns>
         public RateLimitPrecision RateLimitPrecision { get; set; } = RateLimitPrecision.Millisecond;
+
+		/// <summary>
+		/// 	Gets or sets whether or not rate-limits should use the system clock.
+		/// </summary>
+		/// <remarks>
+		///		If set to <c>false</c>, we will use the X-RateLimit-Reset-After header
+		///		to determine when a rate-limit expires, rather than comparing the
+		///		X-RateLimit-Reset timestamp to the system time.
+		///
+		///		This should only be changed to false if the system is known to have
+		/// 	a clock that is out of sync. Relying on the Reset-After header will
+		///		incur network lag.
+		///
+		///		Regardless of this property, we still rely on the system's wall-clock
+		///		to determine if a bucket is rate-limited; we do not use any monotonic
+		///		clock. Your system will still need a stable clock.
+		/// </remarks>
+		public bool UseSystemClock { get; set; } = true;
     }
 }
diff --git a/src/Discord.Net.Core/RequestOptions.cs b/src/Discord.Net.Core/RequestOptions.cs
index 3af3ded6f..6aa0eea12 100644
--- a/src/Discord.Net.Core/RequestOptions.cs
+++ b/src/Discord.Net.Core/RequestOptions.cs
@@ -44,6 +44,18 @@ namespace Discord
         ///     to all actions.
         /// </remarks>
         public string AuditLogReason { get; set; }
+		/// <summary>
+		///		Gets or sets whether or not this request should use the system
+		///		clock for rate-limiting. Defaults to <c>true</c>.
+		/// </summary>
+		/// <remarks>
+		///		This property can also be set in <see cref="DiscordConfig">.
+		///
+		///		On a per-request basis, the system clock should only be disabled 
+		///		when millisecond precision is especially important, and the
+		///		hosting system is known to have a desynced clock.
+		/// </remarks>
+		public bool? UseSystemClock { get; set; }
 
         internal bool IgnoreState { get; set; }
         internal string BucketId { get; set; }
diff --git a/src/Discord.Net.Rest/DiscordRestApiClient.cs b/src/Discord.Net.Rest/DiscordRestApiClient.cs
index c76f31835..ea2a69f5e 100644
--- a/src/Discord.Net.Rest/DiscordRestApiClient.cs
+++ b/src/Discord.Net.Rest/DiscordRestApiClient.cs
@@ -46,12 +46,13 @@ namespace Discord.API
         internal IRestClient RestClient { get; private set; }
         internal ulong? CurrentUserId { get; set; }
         public RateLimitPrecision RateLimitPrecision { get; private set; }
+		internal bool UseSystemClock { get; set; }
         
         internal JsonSerializer Serializer => _serializer;
 
         /// <exception cref="ArgumentException">Unknown OAuth token type.</exception>
         public DiscordRestApiClient(RestClientProvider restClientProvider, string userAgent, RetryMode defaultRetryMode = RetryMode.AlwaysRetry,
-            JsonSerializer serializer = null, RateLimitPrecision rateLimitPrecision = RateLimitPrecision.Second)
+            JsonSerializer serializer = null, RateLimitPrecision rateLimitPrecision = RateLimitPrecision.Second, bool useSystemClock = false)
         {
             _restClientProvider = restClientProvider;
             UserAgent = userAgent;
@@ -265,6 +266,8 @@ namespace Discord.API
                 CheckState();
             if (request.Options.RetryMode == null)
                 request.Options.RetryMode = DefaultRetryMode;
+			if (request.Options.UseSystemClock == null)
+				request.Options.UseSystemClock = UseSystemClock;
 
             var stopwatch = Stopwatch.StartNew();
             var responseStream = await RequestQueue.SendAsync(request).ConfigureAwait(false);
diff --git a/src/Discord.Net.Rest/Net/Queue/RequestQueueBucket.cs b/src/Discord.Net.Rest/Net/Queue/RequestQueueBucket.cs
index d2f77cc39..72dd1642d 100644
--- a/src/Discord.Net.Rest/Net/Queue/RequestQueueBucket.cs
+++ b/src/Discord.Net.Rest/Net/Queue/RequestQueueBucket.cs
@@ -247,12 +247,19 @@ namespace Discord.Net.Queue
                     Debug.WriteLine($"[{id}] Retry-After: {info.RetryAfter.Value} ({info.RetryAfter.Value} ms)");
 #endif
                 }
+				else if (info.ResetAfter.HasValue && (request.Options.UseSystemClock.HasValue ? !request.Options.UseSystemClock.Value : false))
+				{
+					resetTick = DateTimeOffset.Now.Add(info.ResetAfter.Value);
+				}
                 else if (info.Reset.HasValue)
                 {
                     resetTick = info.Reset.Value.AddSeconds(info.Lag?.TotalSeconds ?? 1.0);
 
+					/* millisecond precision makes this unnecessary, retaining in case of regression
+
                     if (request.Options.IsReactionBucket)
                         resetTick = DateTimeOffset.Now.AddMilliseconds(250);
+					*/
 
                     int diff = (int)(resetTick.Value - DateTimeOffset.UtcNow).TotalMilliseconds;
 #if DEBUG_LIMITS
diff --git a/src/Discord.Net.Rest/Net/RateLimitInfo.cs b/src/Discord.Net.Rest/Net/RateLimitInfo.cs
index f193ce6ec..f9d449b70 100644
--- a/src/Discord.Net.Rest/Net/RateLimitInfo.cs
+++ b/src/Discord.Net.Rest/Net/RateLimitInfo.cs
@@ -10,6 +10,7 @@ namespace Discord.Net
         public int? Remaining { get; }
         public int? RetryAfter { get; }
         public DateTimeOffset? Reset { get; }
+		public TimeSpan? ResetAfter { get; }
         public TimeSpan? Lag { get; }
 
         internal RateLimitInfo(Dictionary<string, string> headers)
@@ -24,6 +25,8 @@ namespace Discord.Net
                 float.TryParse(temp, out var reset) ? DateTimeOffset.FromUnixTimeMilliseconds((long)(reset * 1000)) : (DateTimeOffset?)null;
             RetryAfter = headers.TryGetValue("Retry-After", out temp) &&
                 int.TryParse(temp, out var retryAfter) ? retryAfter : (int?)null;
+			ResetAfter = headers.TryGetValue("X-RateLimit-Reset-After", out temp) && 
+				float.TryParse(temp, out var resetAfter) ? TimeSpan.FromMilliseconds((long)(resetAfter * 1000)) : (TimeSpan?)null;
             Lag = headers.TryGetValue("Date", out temp) &&
                 DateTimeOffset.TryParse(temp, out var date) ? DateTimeOffset.UtcNow - date : (TimeSpan?)null;
         }