diff --git a/source/apps/levl/wifi_levl.c b/source/apps/levl/wifi_levl.c
index 0247c5261..0b450893c 100644
--- a/source/apps/levl/wifi_levl.c
+++ b/source/apps/levl/wifi_levl.c
@@ -967,6 +967,7 @@ void levl_disassoc_device_event(wifi_app_t *apps, void *data)
         //Cancel scheduler Task
         if (levl_sc_data->sched_handler_id != 0) {
             scheduler_cancel_timer_task(ctrl->sched, levl_sc_data->sched_handler_id);
+            scheduler_free_timer_task_arg(ctrl->sched, levl_sc_data->sched_handler_id);
             levl_sc_data->sched_handler_id = 0;
         }
         //Disable CSI Sounding
@@ -1163,6 +1164,7 @@ int process_csi_stop_levl(wifi_app_t *app)
         to_mac_str((unsigned char *)levl_sched_data->mac_addr, mac_str);
         if (levl_sched_data->sched_handler_id != 0) {
             scheduler_cancel_timer_task(ctrl->sched, levl_sched_data->sched_handler_id);
+            scheduler_free_timer_task_arg(ctrl->sched, levl_sched_data->sched_handler_id);
             levl_sched_data->sched_handler_id = 0;
         }
         csi_app->data.u.csi.csi_fns.csi_stop_fn(csi_app, levl_sched_data->ap_index, levl_sched_data->mac_addr, wifi_app_inst_levl);
@@ -1467,6 +1469,7 @@ int levl_deinit(wifi_app_t *app)
     //Cancel scheduler Task
     if (app->data.u.levl.probe_collector_sched_handler_id != 0) {
         scheduler_cancel_timer_task(ctrl->sched, app->data.u.levl.probe_collector_sched_handler_id);
+        scheduler_free_timer_task_arg(ctrl->sched, app->data.u.levl.probe_collector_sched_handler_id);
         app->data.u.levl.probe_collector_sched_handler_id = 0;
     }
 
@@ -1495,6 +1498,8 @@ int levl_deinit(wifi_app_t *app)
         to_mac_str((unsigned char *)levl_sched_data->mac_addr, mac_str);
         if (levl_sched_data->sched_handler_id != 0) {
             scheduler_cancel_timer_task(ctrl->sched, levl_sched_data->sched_handler_id);
+            scheduler_free_timer_task_arg(ctrl->sched, levl_sched_data->sched_handler_id);
+            levl_sched_data->sched_handler_id = 0;
         }
         csi_app->data.u.csi.csi_fns.csi_stop_fn(csi_app, levl_sched_data->ap_index, levl_sched_data->mac_addr, wifi_app_inst_levl);
         levl_csi_status_publish(&app->handle, levl_sched_data->mac_addr, 0);
diff --git a/source/apps/whix/wifi_whix.c b/source/apps/whix/wifi_whix.c
index 8c11e616b..4637ce2a1 100644
--- a/source/apps/whix/wifi_whix.c
+++ b/source/apps/whix/wifi_whix.c
@@ -1993,11 +1993,12 @@ static void config_rejected_client_stats(wifi_app_t *app)
     wifi_global_param_t *global_param = get_wifidb_wifi_global_param();
     wifi_ctrl_t *ctrl = (wifi_ctrl_t *)get_wifictrl_obj();
 
+    if (app->data.u.whix.vap_max_client_id != 0) {
+        scheduler_cancel_timer_task(ctrl->sched, app->data.u.whix.vap_max_client_id);
+        scheduler_free_timer_task_arg(ctrl->sched, app->data.u.whix.vap_max_client_id);
+        app->data.u.whix.vap_max_client_id = 0;
+    }   
     if ((global_param != NULL) && (global_param->whix_log_interval != 0)) {
-        if (app->data.u.whix.vap_max_client_id != 0) {
-            scheduler_cancel_timer_task(ctrl->sched, app->data.u.whix.vap_max_client_id);
-            app->data.u.whix.vap_max_client_id = 0;
-        }
         scheduler_add_timer_task(ctrl->sched, FALSE, &app->data.u.whix.vap_max_client_id,
             rejected_client_stats, NULL, (global_param->whix_log_interval * 1000), 0, 0);
     } else {
@@ -2023,6 +2024,7 @@ static int push_whix_config_event_to_monitor_queue(wifi_mon_stats_request_state_
     if (app->data.u.whix.sched_handler_id != 0) {
         wifi_util_dbg_print(WIFI_APPS, "Cancelling scheduler\n");
         scheduler_cancel_timer_task(ctrl->sched, app->data.u.whix.sched_handler_id);
+        scheduler_free_timer_task_arg(ctrl->sched, app->data.u.whix.sched_handler_id);
         app->data.u.whix.sched_handler_id = 0;
         vap_iteration = 0;
         memset(vap_up_arr, 0, sizeof(vap_up_arr));
diff --git a/source/stats/wifi_monitor.c b/source/stats/wifi_monitor.c
index 173e876e8..2b4d8a45b 100644
--- a/source/stats/wifi_monitor.c
+++ b/source/stats/wifi_monitor.c
@@ -5366,6 +5366,8 @@ void coordinator_free_collector_elem(wifi_mon_collector_element_t **collector_el
     return;
 }
 
+static void free_provider_list(wifi_mon_collector_element_t *coll_elem);
+
 int coordinator_create_task(wifi_mon_collector_element_t **collector_elem, wifi_mon_stats_config_t *stats_config, wifi_mon_stats_descriptor_t *stat_desc)
 {
     if (collector_elem == NULL || stats_config == NULL || stat_desc == NULL) {
@@ -5374,6 +5376,7 @@ int coordinator_create_task(wifi_mon_collector_element_t **collector_elem, wifi_
     }
 
     wifi_mon_provider_element_t *provider_elem = NULL;
+    wifi_monitor_t *mon_data = (wifi_monitor_t *)get_wifi_monitor();
     *collector_elem = coordinator_create_collector_elem(stats_config, stat_desc);
     if (*collector_elem == NULL) {
         wifi_util_error_print(WIFI_MON, "%s:%d: coordinator_create_collector_elem failed\n", __func__,__LINE__);
@@ -5389,20 +5392,19 @@ int coordinator_create_task(wifi_mon_collector_element_t **collector_elem, wifi_
     (*collector_elem)->provider_list = hash_map_create();
     if ((*collector_elem)->provider_list == NULL) {
         wifi_util_error_print(WIFI_MON, "%s:%d: hash map failed for provider list\n", __func__,__LINE__);
-        coordinator_free_collector_elem(collector_elem);
-        return RETURN_ERR;
+        goto fail;
     }
 
     provider_elem = coordinator_create_provider_elem(stats_config, stat_desc);
     if (provider_elem == NULL) {
         wifi_util_error_print(WIFI_MON, "%s:%d: coordinator_create_provider_elem failed\n", __func__,__LINE__);
-        return RETURN_ERR;
+        goto fail;
     }
     char* key_copy = strdup(provider_elem->key);
     if (key_copy == NULL) {
         wifi_util_error_print(WIFI_MON, "%s:%d: strdup failed\n", __func__,__LINE__);
         coordinator_free_provider_elem(&provider_elem);
-        return RETURN_ERR;
+        goto fail;
     }
 
     if (hash_map_put((*collector_elem)->provider_list, key_copy, provider_elem) != 0) {
@@ -5414,14 +5416,21 @@ int coordinator_create_task(wifi_mon_collector_element_t **collector_elem, wifi_
     if (stat_desc->copy_stats_from_cache != NULL) {
         if (coordinator_create_provider_task(provider_elem) != RETURN_OK) {
             wifi_util_error_print(WIFI_MON, "%s:%d: coordinator_create_provider_task failed\n", __func__,__LINE__);
+            hash_map_remove((*collector_elem)->provider_list, provider_elem->key);
             coordinator_free_provider_elem(&provider_elem);
-            return RETURN_ERR;
+            goto fail;
         }
     } else {
         provider_elem->provider_task_sched_id = 0;
     }
 
     return RETURN_OK;
+
+fail:
+    scheduler_cancel_timer_task(mon_data->sched, (*collector_elem)->collector_task_sched_id);  
+    free_provider_list(*collector_elem);  
+    coordinator_free_collector_elem(collector_elem);  
+    return RETURN_ERR;
 }
 
 int collector_task_update(wifi_mon_collector_element_t *collector_elem, unsigned long *new_collector_interval)
@@ -5491,6 +5500,7 @@ int coordinator_update_task(wifi_mon_collector_element_t *collector_elem, wifi_m
         if (collector_elem->stat_desc->copy_stats_from_cache != NULL) {
             if (coordinator_create_provider_task(provider_elem) != RETURN_OK) {
                 wifi_util_error_print(WIFI_MON, "%s:%d: coordinator_create_provider_task failed\n", __func__,__LINE__);
+                hash_map_remove(collector_elem->provider_list, provider_elem->key); 
                 coordinator_free_provider_elem(&provider_elem);
                 return RETURN_ERR;
             }
@@ -5601,17 +5611,18 @@ int coordinator_check_stats_config(wifi_mon_stats_config_t *mon_stats_config)
     collector_elem = (wifi_mon_collector_element_t *)hash_map_get(collector_list, stats_key);
     if (collector_elem == NULL) {
         if (mon_stats_config->req_state == mon_stats_request_state_start) {
+            char *key_copy = strdup(stats_key);
+            if (key_copy == NULL) { 
+                wifi_util_error_print(WIFI_MON, "%s:%d: Failed to duplicate key\n", __func__,  
+                    __LINE__);  
+                return RETURN_ERR;  
+            }
             if (coordinator_create_task(&collector_elem, mon_stats_config, stat_desc) !=
                 RETURN_OK) {
                 wifi_util_error_print(WIFI_MON,
                     "%s:%d: create task failed for key : %s for app  %d\n", __func__, __LINE__,
                     stats_key, mon_stats_config->inst);
-                return RETURN_ERR;
-            }
-            char *key_copy = strdup(stats_key);
-            if (key_copy == NULL) {
-                wifi_util_error_print(WIFI_MON, "%s:%d: Failed to duplicate key\n", __func__,
-                    __LINE__);
+                free(key_copy);
                 return RETURN_ERR;
             }
             clctr_subscription = hash_map_get(mon_data->clctr_subscriber_map, stats_key);
@@ -5664,7 +5675,7 @@ hash_map_t *coordinator_get_collector_list()
     return apps_coordinator->collector_list;
 }
 
-void free_provider_list(wifi_mon_collector_element_t *coll_elem)
+static void free_provider_list(wifi_mon_collector_element_t *coll_elem)
 {
     wifi_mon_provider_element_t *provider_elem, *temp_provider;
     char key[MON_STATS_KEY_LEN_32] = {0};