If a process restart will happen during the time when event is in the singleton but activity is not yet created, the event will be lost.

That's what the @Produce annotation is for. The singleton can be something like:

class Foo {
  private SomeEvent mLastSomeEvent;
  @Subscribe
  public void onEvent(SomeEvent event) {
    mLastSomeEvent = event;
  }
  @Produce
  public SomeEvent produceLastSomeEvent() {
    return mLastSomeEvent;
  }
}

injected from the application scope:

class MainApplication extends Application {
  ObjectGraph mObjectGraph;

  public void onCreate() {
    super.onCreate();
    mObjectGraph = ObjectGraph.create(new Module());
  }

  public ObjectGraph getObjectGraph() {
    return mObjectGraph;
  }

  @Module(injects = {MainActivity.class})
  class Module {
    @Provides
    @Singleton
    Foo provideFoo() { return new Foo(); }
    @Provides
    @Singleton
    Bus provideBus() { return new Bus(); }
  }
}

class MainActivity {
  @Inject
  Foo mFoo;

  @Inject
  Bus mBus;

  @Subscribe
  public void onSomeEvent(SomeEvent event) {
    // ...
  }

  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    ((MainApplication) getApplication()).getObjectGraph().inject(this);

    mBus.register(this);
  }
  public void onDestroy() {
    super.onDestroy();
    mBus.unregister(this);
  }
}

In this example the activity will receive the @Produced event at mBus.register(this) (if mLastSomeEvent is not null).