diff --git a/src/util/scheduler.cpp b/src/util/scheduler.cpp
index c2f5564..9af996a 100644
--- a/src/util/scheduler.cpp
+++ b/src/util/scheduler.cpp
@@ -23,6 +23,24 @@
 
 #include "scheduler.hpp"
 
+namespace ns3 {
+
+/// @cond include_hidden
+
+template<>
+struct EventMemberImplObjTraits<std::function<void()>> {
+  typedef std::function<void()> T;
+  static T&
+  GetReference(T& p)
+  {
+    return p;
+  }
+};
+
+/// @endcond
+
+} // namespace ns3
+
 namespace ndn {
 namespace util {
 namespace scheduler {
@@ -92,8 +110,6 @@
 
 Scheduler::Scheduler(boost::asio::io_service& ioService)
   : m_scheduledEvent(m_events.end())
-  , m_deadlineTimer(ioService)
-  , m_isEventExecuting(false)
 {
 }
 
@@ -101,102 +117,35 @@
 Scheduler::scheduleEvent(const time::nanoseconds& after,
                          const Event& event)
 {
-  EventQueue::iterator i = m_events.insert(EventInfo(after, event));
-
-  // On OSX 10.9, boost, and C++03 the following doesn't work without ndn::
-  // because the argument-dependent lookup prefers STL to boost
-  i->m_eventId = ndn::make_shared<EventIdImpl>(i);
-
-  if (!m_isEventExecuting)
-    {
-      if (m_scheduledEvent == m_events.end() ||
-          *i < *m_scheduledEvent)
-        {
-          m_deadlineTimer.expires_from_now(after);
-          m_deadlineTimer.async_wait(bind(&Scheduler::onEvent, this, _1));
-          m_scheduledEvent = i;
-        }
-    }
-
-  return i->m_eventId;
+  ns3::EventId id = ns3::Simulator::Schedule(ns3::NanoSeconds(after.count()),
+                                             &std::function<void()>::operator(), event);
+  auto id_ptr = std::make_shared<ns3::EventId>(id);
+  m_events.insert(id_ptr);
+  return id_ptr;
 }
 
 void
 Scheduler::cancelEvent(const EventId& eventId)
 {
-  if (!static_cast<bool>(eventId) || !eventId->isValid())
-    return; // event already fired or cancelled
-
-  if (static_cast<EventQueue::iterator>(*eventId) != m_scheduledEvent) {
-    m_events.erase(*eventId);
-    eventId->invalidate();
-    return;
+  if (eventId != nullptr) {
+    ns3::Simulator::Remove(*eventId);
+    const_cast<EventId&>(eventId).reset();
+    m_events.erase(eventId);
   }
-
-  m_deadlineTimer.cancel();
-  m_events.erase(static_cast<EventQueue::iterator>(*eventId));
-  eventId->invalidate();
-
-  if (!m_isEventExecuting)
-    {
-      if (!m_events.empty())
-        {
-          m_deadlineTimer.expires_from_now(m_events.begin()->expiresFromNow());
-          m_deadlineTimer.async_wait(bind(&Scheduler::onEvent, this, _1));
-          m_scheduledEvent = m_events.begin();
-        }
-      else
-        {
-          m_scheduledEvent = m_events.end();
-        }
-    }
 }
 
 void
 Scheduler::cancelAllEvents()
 {
+  for (auto i = m_events.begin(); i != m_events.end(); i++) {
+    if ((*i) != nullptr) {
+      ns3::Simulator::Remove((**i));
+      const_cast<EventId&>(*i).reset();
+    }
+  }
   m_events.clear();
-  m_deadlineTimer.cancel();
 }
 
-void
-Scheduler::onEvent(const boost::system::error_code& error)
-{
-  if (error) // e.g., cancelled
-    {
-      return;
-    }
-
-  m_isEventExecuting = true;
-
-  // process all expired events
-  time::steady_clock::TimePoint now = time::steady_clock::now();
-  while(!m_events.empty() && m_events.begin()->m_scheduledTime <= now)
-    {
-      EventQueue::iterator head = m_events.begin();
-
-      Event event = head->m_event;
-      head->m_eventId->invalidate();
-      m_events.erase(head);
-
-      event();
-    }
-
-  if (!m_events.empty())
-    {
-      m_deadlineTimer.expires_from_now(m_events.begin()->m_scheduledTime - now);
-      m_deadlineTimer.async_wait(bind(&Scheduler::onEvent, this, _1));
-      m_scheduledEvent = m_events.begin();
-    }
-  else
-    {
-      m_scheduledEvent = m_events.end();
-    }
-
-  m_isEventExecuting = false;
-}
-
-
 } // namespace scheduler
 } // namespace util
 } // namespace ndn
diff --git a/src/util/scheduler.hpp b/src/util/scheduler.hpp
index 8948860..c9dc3cf 100644
--- a/src/util/scheduler.hpp
+++ b/src/util/scheduler.hpp
@@ -25,6 +25,8 @@
 #include "../common.hpp"
 #include "monotonic_deadline_timer.hpp"
 
+#include "ns3/simulator.h"
+
 #include <set>
 
 namespace ndn {
@@ -32,10 +34,11 @@
 namespace scheduler {
 
 struct EventIdImpl; ///< \brief Private storage of information about the event
-/**
- * \brief Opaque type (shared_ptr) representing ID of the scheduled event
+
+/** \class EventId
+ *  \brief Opaque type (shared_ptr) representing ID of a scheduled event
  */
-typedef shared_ptr<EventIdImpl> EventId;
+typedef std::shared_ptr<ns3::EventId> EventId;
 
 /**
  * \brief Generic scheduler
@@ -67,10 +70,6 @@
   cancelAllEvents();
 
 private:
-  void
-  onEvent(const boost::system::error_code& code);
-
-private:
   struct EventInfo
   {
     EventInfo(const time::nanoseconds& after, const Event& event);
@@ -97,14 +96,11 @@
     mutable EventId m_eventId;
   };
 
-  typedef std::multiset<EventInfo> EventQueue;
+  typedef std::multiset<EventId> EventQueue;
   friend struct EventIdImpl;
 
   EventQueue m_events;
   EventQueue::iterator m_scheduledEvent;
-  monotonic_deadline_timer m_deadlineTimer;
-
-  bool m_isEventExecuting;
 };
 
 } // namespace scheduler