diff --git a/CryptoExchange.Net/Clients/BaseApiClient.cs b/CryptoExchange.Net/Clients/BaseApiClient.cs
index f47c8fdf..8d1889be 100644
--- a/CryptoExchange.Net/Clients/BaseApiClient.cs
+++ b/CryptoExchange.Net/Clients/BaseApiClient.cs
@@ -93,6 +93,17 @@ public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
                 AuthenticationProvider = CreateAuthenticationProvider(credentials.Copy());
         }
 
+        /// <inheritdoc />
+        public virtual void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials
+        {
+            ClientOptions.Proxy = options.Proxy;
+            ClientOptions.RequestTimeout = options.RequestTimeout ?? ClientOptions.RequestTimeout;
+
+            ApiOptions.ApiCredentials = options.ApiCredentials ?? ClientOptions.ApiCredentials;
+            if (options.ApiCredentials != null)
+                AuthenticationProvider = CreateAuthenticationProvider(options.ApiCredentials.Copy());
+        }
+
         /// <summary>
         /// Dispose
         /// </summary>
diff --git a/CryptoExchange.Net/Clients/RestApiClient.cs b/CryptoExchange.Net/Clients/RestApiClient.cs
index 41e22d16..91e999a9 100644
--- a/CryptoExchange.Net/Clients/RestApiClient.cs
+++ b/CryptoExchange.Net/Clients/RestApiClient.cs
@@ -961,6 +961,14 @@ protected internal IDictionary<string, object> CreateParameterDictionary(IDictio
         /// <returns>Server time</returns>
         protected virtual Task<WebCallResult<DateTime>> GetServerTimestampAsync() => throw new NotImplementedException();
 
+        /// <inheritdoc />
+        public override void SetOptions<T>(UpdateOptions<T> options)
+        {
+            base.SetOptions(options);
+
+            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout);
+        }
+
         internal async Task<WebCallResult<bool>> SyncTimeAsync()
         {
             var timeSyncParams = GetTimeSyncInfo();
diff --git a/CryptoExchange.Net/Clients/SocketApiClient.cs b/CryptoExchange.Net/Clients/SocketApiClient.cs
index d27ee3df..1adcba6d 100644
--- a/CryptoExchange.Net/Clients/SocketApiClient.cs
+++ b/CryptoExchange.Net/Clients/SocketApiClient.cs
@@ -158,7 +158,7 @@ protected virtual void SetDedicatedConnection(string url, bool auth)
         /// <param name="interval"></param>
         /// <param name="queryDelegate"></param>
         /// <param name="callback"></param>
-        protected virtual void RegisterPeriodicQuery(string identifier, TimeSpan interval, Func<SocketConnection, Query> queryDelegate, Action<CallResult>? callback)
+        protected virtual void RegisterPeriodicQuery(string identifier, TimeSpan interval, Func<SocketConnection, Query> queryDelegate, Action<SocketConnection, CallResult>? callback)
         {
             PeriodicTaskRegistrations.Add(new PeriodicTaskRegistration
             {
@@ -422,9 +422,10 @@ public virtual async Task<CallResult> AuthenticateSocketAsync(SocketConnection s
                     result.Error!.Message = "Authentication failed: " + result.Error.Message;
                     return new CallResult(result.Error)!;
                 }
+
+                _logger.Authenticated(socket.SocketId);
             }
 
-            _logger.Authenticated(socket.SocketId);
             socket.Authenticated = true;
             return new CallResult(null);
         }
@@ -710,6 +711,25 @@ public virtual async Task<CallResult> PrepareConnectionsAsync()
             return new CallResult(null);
         }
 
+        /// <inheritdoc />
+        public override void SetOptions<T>(UpdateOptions<T> options)
+        {
+            var previousProxyIsSet = ClientOptions.Proxy != null;
+            base.SetOptions(options);
+
+            if ((!previousProxyIsSet && options.Proxy == null)
+                || !socketConnections.Any())
+            {
+                return;
+            }
+
+            _logger.LogInformation("Reconnecting websockets to apply proxy");
+
+            // Update proxy, also triggers reconnect
+            foreach (var connection in socketConnections)
+                _ = connection.Value.UpdateProxy(options.Proxy);
+        }
+
         /// <summary>
         /// Log the current state of connections and subscriptions
         /// </summary>
diff --git a/CryptoExchange.Net/Interfaces/IBaseApiClient.cs b/CryptoExchange.Net/Interfaces/IBaseApiClient.cs
index 548a196c..9b321b11 100644
--- a/CryptoExchange.Net/Interfaces/IBaseApiClient.cs
+++ b/CryptoExchange.Net/Interfaces/IBaseApiClient.cs
@@ -1,5 +1,6 @@
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using System;
 
@@ -31,5 +32,12 @@ public interface IBaseApiClient
         /// <typeparam name="T"></typeparam>
         /// <param name="credentials"></param>
         void SetApiCredentials<T>(T credentials) where T : ApiCredentials;
+
+        /// <summary>
+        /// Set new options. Note that when using a proxy this should be provided in the options even when already set before or it will be reset.
+        /// </summary>
+        /// <typeparam name="T">Api crentials type</typeparam>
+        /// <param name="options">Options to set</param>
+        void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials;
     }
 }
\ No newline at end of file
diff --git a/CryptoExchange.Net/Interfaces/IRequestFactory.cs b/CryptoExchange.Net/Interfaces/IRequestFactory.cs
index 66ff9067..f3cc827c 100644
--- a/CryptoExchange.Net/Interfaces/IRequestFactory.cs
+++ b/CryptoExchange.Net/Interfaces/IRequestFactory.cs
@@ -24,6 +24,13 @@ public interface IRequestFactory
         /// <param name="requestTimeout">Request timeout to use</param>
         /// <param name="httpClient">Optional shared http client instance</param>
         /// <param name="proxy">Optional proxy to use when no http client is provided</param>
-        void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient=null);
+        void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient = null);
+
+        /// <summary>
+        /// Update settings
+        /// </summary>
+        /// <param name="proxy">Proxy to use</param>
+        /// <param name="requestTimeout">Request timeout to use</param>
+        void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout);
     }
 }
diff --git a/CryptoExchange.Net/Interfaces/IWebsocket.cs b/CryptoExchange.Net/Interfaces/IWebsocket.cs
index b1e75cb7..721688df 100644
--- a/CryptoExchange.Net/Interfaces/IWebsocket.cs
+++ b/CryptoExchange.Net/Interfaces/IWebsocket.cs
@@ -93,5 +93,10 @@ public interface IWebsocket: IDisposable
         /// </summary>
         /// <returns></returns>
         Task CloseAsync();
+
+        /// <summary>
+        /// Update proxy setting
+        /// </summary>
+        void UpdateProxy(ApiProxy? proxy);
     }
 }
diff --git a/CryptoExchange.Net/Objects/Options/UpdateOptions.cs b/CryptoExchange.Net/Objects/Options/UpdateOptions.cs
new file mode 100644
index 00000000..9fc9ed04
--- /dev/null
+++ b/CryptoExchange.Net/Objects/Options/UpdateOptions.cs
@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Authentication;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.Objects.Options
+{
+    /// <summary>
+    /// Options to update
+    /// </summary>
+    public class UpdateOptions<T> where T : ApiCredentials
+    {
+        /// <summary>
+        /// Proxy setting. Note that if this is not provided any previously set proxy will be reset
+        /// </summary>
+        public ApiProxy? Proxy { get; set; }
+        /// <summary>
+        /// Api credentials
+        /// </summary>
+        public T? ApiCredentials { get; set; }
+        /// <summary>
+        /// Request timeout
+        /// </summary>
+        public TimeSpan? RequestTimeout { get; set; }
+    }
+
+    /// <inheritdoc />
+    public class UpdateOptions : UpdateOptions<ApiCredentials> { }
+}
diff --git a/CryptoExchange.Net/Requests/RequestFactory.cs b/CryptoExchange.Net/Requests/RequestFactory.cs
index 83ea61df..693e91d5 100644
--- a/CryptoExchange.Net/Requests/RequestFactory.cs
+++ b/CryptoExchange.Net/Requests/RequestFactory.cs
@@ -17,28 +17,7 @@ public class RequestFactory : IRequestFactory
         public void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? client = null)
         {
             if (client == null)
-            {
-                var handler = new HttpClientHandler();
-                try
-                {
-                    handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
-                }
-                catch (PlatformNotSupportedException) { }
-
-                if (proxy != null)
-                {
-                    handler.Proxy = new WebProxy
-                    {
-                        Address = new Uri($"{proxy.Host}:{proxy.Port}"),
-                        Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
-                    };
-                }
-
-                client = new HttpClient(handler)
-                {
-                    Timeout = requestTimeout
-                };
-            }
+                client = CreateClient(proxy, requestTimeout);
 
             _httpClient = client;
         }
@@ -51,5 +30,37 @@ public IRequest Create(HttpMethod method, Uri uri, int requestId)
 
             return new Request(new HttpRequestMessage(method, uri), _httpClient, requestId);
         }
+
+        /// <inheritdoc />
+        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout)
+        {
+            _httpClient = CreateClient(proxy, requestTimeout);
+        }
+
+        private HttpClient CreateClient(ApiProxy? proxy, TimeSpan requestTimeout)
+        {
+            var handler = new HttpClientHandler();
+            try
+            {
+                handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                handler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
+            }
+            catch (PlatformNotSupportedException) { }
+
+            if (proxy != null)
+            {
+                handler.Proxy = new WebProxy
+                {
+                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
+                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                };
+            }
+
+            var client = new HttpClient(handler)
+            {
+                Timeout = requestTimeout
+            };
+            return client;
+        }
     }
 }
diff --git a/CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs b/CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs
index fd3fb650..1d364ebd 100644
--- a/CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs
+++ b/CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs
@@ -155,6 +155,12 @@ public CryptoExchangeWebSocketClient(ILogger logger, WebSocketParameters websock
             _baseAddress = $"{Uri.Scheme}://{Uri.Host}";
         }
 
+        /// <inheritdoc />
+        public void UpdateProxy(ApiProxy? proxy)
+        {
+            Parameters.Proxy = proxy;
+        }
+
         /// <inheritdoc />
         public virtual async Task<CallResult> ConnectAsync()
         {
@@ -435,8 +441,8 @@ private async Task CloseInternalAsync()
                     {
                         // Wait until we receive close confirmation
                         await Task.Delay(10).ConfigureAwait(false);
-                        if (DateTime.UtcNow - startWait > TimeSpan.FromSeconds(5))
-                            break; // Wait for max 5 seconds, then just abort the connection
+                        if (DateTime.UtcNow - startWait > TimeSpan.FromSeconds(1))
+                            break; // Wait for max 1 second, then just abort the connection
                     }
                 }
             }
diff --git a/CryptoExchange.Net/Sockets/PeriodicTaskRegistration.cs b/CryptoExchange.Net/Sockets/PeriodicTaskRegistration.cs
index 8f9ccaf7..9c532bba 100644
--- a/CryptoExchange.Net/Sockets/PeriodicTaskRegistration.cs
+++ b/CryptoExchange.Net/Sockets/PeriodicTaskRegistration.cs
@@ -23,6 +23,6 @@ public class PeriodicTaskRegistration
         /// <summary>
         /// Callback after query
         /// </summary>
-        public Action<CallResult>? Callback { get; set; }
+        public Action<SocketConnection, CallResult>? Callback { get; set; }
     }
 }
diff --git a/CryptoExchange.Net/Sockets/Query.cs b/CryptoExchange.Net/Sockets/Query.cs
index 833abf8b..397ae433 100644
--- a/CryptoExchange.Net/Sockets/Query.cs
+++ b/CryptoExchange.Net/Sockets/Query.cs
@@ -23,6 +23,11 @@ public abstract class Query : IMessageProcessor
         /// </summary>
         public bool Completed { get; set; }
 
+        /// <summary>
+        /// Timeout for the request
+        /// </summary>
+        public TimeSpan? RequestTimeout { get; set; }
+
         /// <summary>
         /// The number of required responses. Can be more than 1 when for example subscribing multiple symbols streams in a single request,
         /// and each symbol receives it's own confirmation response
diff --git a/CryptoExchange.Net/Sockets/SocketConnection.cs b/CryptoExchange.Net/Sockets/SocketConnection.cs
index 3e4364f7..a1deaaa6 100644
--- a/CryptoExchange.Net/Sockets/SocketConnection.cs
+++ b/CryptoExchange.Net/Sockets/SocketConnection.cs
@@ -11,6 +11,8 @@
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Logging.Extensions;
 using System.Threading;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Authentication;
 
 namespace CryptoExchange.Net.Sockets
 {
@@ -437,7 +439,7 @@ protected virtual Task HandleRequestSentAsync(int requestId)
                 return Task.CompletedTask;
             }
 
-            query.IsSend(ApiClient.ClientOptions.RequestTimeout);
+            query.IsSend(query.RequestTimeout ?? ApiClient.ClientOptions.RequestTimeout);
             return Task.CompletedTask;
         }
 
@@ -583,6 +585,16 @@ protected virtual async Task HandleStreamMessage(WebSocketMessageType type, Read
         /// <returns></returns>
         public async Task TriggerReconnectAsync() => await _socket.ReconnectAsync().ConfigureAwait(false);
 
+        /// <summary>
+        /// Update the proxy setting and reconnect
+        /// </summary>
+        /// <param name="proxy">New proxy setting</param>
+        public async Task UpdateProxy(ApiProxy? proxy)
+        {
+            _socket.UpdateProxy(proxy);
+            await TriggerReconnectAsync().ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Close the connection
         /// </summary>
@@ -988,7 +1000,7 @@ internal async Task<CallResult> ResubscribeAsync(Subscription subscription)
         /// <param name="interval">How often</param>
         /// <param name="queryDelegate">Method returning the query to send</param>
         /// <param name="callback">The callback for processing the response</param>
-        public virtual void QueryPeriodic(string identifier, TimeSpan interval, Func<SocketConnection, Query> queryDelegate, Action<CallResult>? callback)
+        public virtual void QueryPeriodic(string identifier, TimeSpan interval, Func<SocketConnection, Query> queryDelegate, Action<SocketConnection, CallResult>? callback)
         {
             if (queryDelegate == null)
                 throw new ArgumentNullException(nameof(queryDelegate));
@@ -1020,7 +1032,7 @@ public virtual void QueryPeriodic(string identifier, TimeSpan interval, Func<Soc
                     try
                     {
                         var result = await SendAndWaitQueryAsync(query).ConfigureAwait(false);
-                        callback?.Invoke(result);
+                        callback?.Invoke(this, result);
                     }
                     catch (Exception ex)
                     {
diff --git a/CryptoExchange.Net/Testing/Implementations/TestRequestFactory.cs b/CryptoExchange.Net/Testing/Implementations/TestRequestFactory.cs
index 6bcd8c1a..293c2ead 100644
--- a/CryptoExchange.Net/Testing/Implementations/TestRequestFactory.cs
+++ b/CryptoExchange.Net/Testing/Implementations/TestRequestFactory.cs
@@ -25,5 +25,7 @@ public IRequest Create(HttpMethod method, Uri uri, int requestId)
             _request.RequestId = requestId;
             return _request;
         }
+
+        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout) {}
     }
 }
diff --git a/CryptoExchange.Net/Testing/Implementations/TestSocket.cs b/CryptoExchange.Net/Testing/Implementations/TestSocket.cs
index b65cfa31..bec8b8d9 100644
--- a/CryptoExchange.Net/Testing/Implementations/TestSocket.cs
+++ b/CryptoExchange.Net/Testing/Implementations/TestSocket.cs
@@ -92,5 +92,7 @@ public void InvokeMessage<T>(T data)
 
         public Task ReconnectAsync() => throw new NotImplementedException();
         public void Dispose() { }
+
+        public void UpdateProxy(ApiProxy? proxy) => throw new NotImplementedException();
     }
 }
diff --git a/CryptoExchange.Net/Trackers/Trades/TradeTracker.cs b/CryptoExchange.Net/Trackers/Trades/TradeTracker.cs
index 89625668..05bc2090 100644
--- a/CryptoExchange.Net/Trackers/Trades/TradeTracker.cs
+++ b/CryptoExchange.Net/Trackers/Trades/TradeTracker.cs
@@ -350,7 +350,8 @@ protected void SetInitialData(IEnumerable<SharedTrade> data)
                     _data.Add(item);
                 }
 
-                _firstTimestamp = _data.Min(v => v.Timestamp);
+                if (_data.Any())
+                    _firstTimestamp = _data.Min(v => v.Timestamp);
 
                 ApplyWindow(false);
             }