diff --git a/keystore2/src/async_task.rs b/keystore2/src/async_task.rs
index 45f0274..e130024 100644
--- a/keystore2/src/async_task.rs
+++ b/keystore2/src/async_task.rs
@@ -19,7 +19,6 @@
 //! processed all tasks before it terminates.
 //! Note that low priority tasks are processed only when the high priority queue is empty.
 
-use crate::utils::watchdog as wd;
 use std::{any::Any, any::TypeId, time::Duration};
 use std::{
     collections::{HashMap, VecDeque},
@@ -241,14 +240,11 @@
                     // Now that the lock has been dropped, perform the action.
                     match action {
                         Action::QueuedFn(f) => {
-                            let _wd = wd::watch_millis("async_task thread: calling queued fn", 500);
                             f(&mut shelf);
                             done_idle = false;
                         }
                         Action::IdleFns(idle_fns) => {
                             for idle_fn in idle_fns {
-                                let _wd =
-                                    wd::watch_millis("async_task thread: calling idle_fn", 500);
                                 idle_fn(&mut shelf);
                             }
                             done_idle = true;
diff --git a/keystore2/src/keystore2_main.rs b/keystore2/src/keystore2_main.rs
index dab6867..a6a25b2 100644
--- a/keystore2/src/keystore2_main.rs
+++ b/keystore2/src/keystore2_main.rs
@@ -133,12 +133,7 @@
         },
     );
 
-    std::thread::spawn(|| {
-        match metrics::register_pull_metrics_callbacks() {
-            Err(e) => error!("register_pull_metrics_callbacks failed: {:?}.", e),
-            _ => info!("Pull metrics callbacks successfully registered."),
-        };
-    });
+    metrics::register_pull_metrics_callbacks();
 
     info!("Successfully registered Keystore 2.0 service.");
 
diff --git a/keystore2/src/metrics.rs b/keystore2/src/metrics.rs
index 07c3d64..10a465c 100644
--- a/keystore2/src/metrics.rs
+++ b/keystore2/src/metrics.rs
@@ -23,7 +23,7 @@
     KeyParameter::KeyParameter, KeyPurpose::KeyPurpose, PaddingMode::PaddingMode,
     SecurityLevel::SecurityLevel,
 };
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use keystore2_system_property::PropertyWatcher;
 use statslog_rust::{
     keystore2_key_creation_event_reported::{
@@ -40,6 +40,47 @@
 use statslog_rust_header::Atoms;
 use statspull_rust::{set_pull_atom_callback, StatsPullResult};
 
+// Waits and returns Ok if boot is completed.
+fn wait_for_boot_completed() -> Result<()> {
+    let watcher = PropertyWatcher::new("sys.boot_completed");
+    match watcher {
+        Ok(mut watcher) => {
+            loop {
+                let wait_result = watcher.wait();
+                match wait_result {
+                    Ok(_) => {
+                        let value_result =
+                            watcher.read(|_name, value| Ok(value.trim().to_string()));
+                        match value_result {
+                            Ok(value) => {
+                                if value == "1" {
+                                    break;
+                                }
+                            }
+                            Err(e) => {
+                                log::error!(
+                                    "In wait_for_boot_completed: Failed while reading property. {}",
+                                    e
+                                );
+                                return Err(anyhow!("Error in waiting for boot completion."));
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("In wait_for_boot_completed: Failed while waiting. {}", e);
+                        return Err(anyhow!("Error in waiting for boot completion."));
+                    }
+                }
+            }
+            Ok(())
+        }
+        Err(e) => {
+            log::error!("In wait_for_boot_completed: Failed to create PropertyWatcher. {}", e);
+            Err(anyhow!("Error in waiting for boot completion."))
+        }
+    }
+}
+
 fn create_default_key_creation_atom() -> Keystore2KeyCreationEventReported {
     // If a value is not present, fields represented by bitmaps and i32 fields
     // will take 0, except error_code which defaults to 1 indicating NO_ERROR and key_size,
@@ -89,10 +130,10 @@
         construct_key_creation_event_stats(sec_level, key_params, result);
 
     LOGS_HANDLER.queue_lo(move |_| {
-        let logging_result = key_creation_event_stats.stats_write();
-
-        if let Err(e) = logging_result {
-            log::error!("Error in logging key creation event in the async task. {:?}", e);
+        if let Ok(()) = wait_for_boot_completed() {
+            if let Err(e) = key_creation_event_stats.stats_write() {
+                log::error!("Error in logging key creation event in the async task. {:?}", e);
+            }
         }
     });
 }
@@ -114,10 +155,10 @@
     );
 
     LOGS_HANDLER.queue_lo(move |_| {
-        let logging_result = key_operation_event_stats.stats_write();
-
-        if let Err(e) = logging_result {
-            log::error!("Error in logging key operation event in the async task. {:?}", e);
+        if let Ok(()) = wait_for_boot_completed() {
+            if let Err(e) = key_operation_event_stats.stats_write() {
+                log::error!("Error in logging key operation event in the async task. {:?}", e);
+            }
         }
     });
 }
@@ -383,21 +424,17 @@
 }
 
 /// Registers pull metrics callbacks
-pub fn register_pull_metrics_callbacks() -> Result<()> {
+pub fn register_pull_metrics_callbacks() {
     // Before registering the callbacks with statsd, we have to wait for the system to finish
     // booting up. This avoids possible races that may occur at startup. For example, statsd
     // depends on a companion service, and if registration happens too soon it will fail since
     // the companion service isn't up yet.
-    let mut watcher = PropertyWatcher::new("sys.boot_completed")?;
-    loop {
-        watcher.wait()?;
-        let value = watcher.read(|_name, value| Ok(value.trim().to_string()));
-        if value? == "1" {
+    LOGS_HANDLER.queue_lo(move |_| {
+        if let Ok(()) = wait_for_boot_completed() {
             set_pull_atom_callback(Atoms::Keystore2StorageStats, None, pull_metrics_callback);
-            break;
+            log::info!("Pull metrics callbacks successfully registered.")
         }
-    }
-    Ok(())
+    });
 }
 
 fn pull_metrics_callback() -> StatsPullResult {