diff --git a/main.cpp b/main.cpp
index 488447c..9928f63 100644
--- a/main.cpp
+++ b/main.cpp
@@ -148,7 +148,6 @@
       unique_ptr<HostapdManager>(new HostapdManager()),
       &netlink_utils,
       &scan_utils));
-  server->CleanUpSystemState();
   RegisterServiceOrCrash(server.get());
 
   event_dispatcher->Poll();
diff --git a/server.cpp b/server.cpp
index 4e4796c..59745f1 100644
--- a/server.cpp
+++ b/server.cpp
@@ -256,12 +256,6 @@
   }
 }
 
-void Server::CleanUpSystemState() {
-  supplicant_manager_->StopSupplicant();
-  hostapd_manager_->StopHostapd();
-  MarkDownAllInterfaces();
-}
-
 Status Server::getAvailable2gChannels(
     std::unique_ptr<vector<int32_t>>* out_frequencies) {
   BandInfo band_info;
diff --git a/server.h b/server.h
index 70505c0..fe54242 100644
--- a/server.h
+++ b/server.h
@@ -95,11 +95,6 @@
       std::vector<android::sp<android::IBinder>>* out_ap_ifs) override;
   status_t dump(int fd, const Vector<String16>& args) override;
 
-  // Call this once on startup.  It ignores all the invariants held
-  // in wificond and tries to restore ourselves to a blank state by
-  // killing userspace daemons and cleaning up the interface state.
-  void CleanUpSystemState();
-
  private:
   // Request interface information from kernel and setup local interface object.
   // This assumes that interface should be in STATION mode. Even if we setup
