diff --git a/hgext3rd/fbamend/restack.py b/hgext3rd/fbamend/restack.py
--- a/hgext3rd/fbamend/restack.py
+++ b/hgext3rd/fbamend/restack.py
@@ -7,15 +7,12 @@
 
 from __future__ import absolute_import
 
-from collections import deque
-
 from mercurial import (
-    cmdutil,
     commands,
-    error,
+    revsetlang,
 )
 
-from . import common
+from hgext import rebase
 
 def restack(ui, repo, rebaseopts=None):
     """Repair a situation in which one or more changesets in a stack
@@ -23,91 +20,39 @@
        unstable) by finding any such changesets and rebasing their descendants
        onto the latest version of each respective changeset.
     """
-    if rebaseopts is None:
-        rebaseopts = {}
-
-    with repo.wlock(), repo.lock():
-        cmdutil.checkunfinished(repo)
-        cmdutil.bailifchanged(repo)
+    rebaseopts = (rebaseopts or {}).copy()
 
-        # Find the latest version of the changeset at the botom of the
-        # current stack. If the current changeset is public, simply start
-        # restacking from the current changeset with the assumption
-        # that there are non-public changesets higher up.
-        base = repo.revs('::. & draft()').first()
-        latest = (common.latest(repo, base) if base is not None
-                                     else repo['.'].rev())
-        targets = _findrestacktargets(repo, latest)
+    # Find drafts connected to the current stack via either changelog or
+    # obsolete graph. Note: "draft() & ::." is optimized by D441.
 
-        with repo.transaction('restack') as tr:
-            # Attempt to stabilize all changesets that are or will be (after
-            # rebasing) descendants of base.
-            for rev in targets:
-                try:
-                    common.restackonce(ui, repo, rev, rebaseopts)
-                except error.InterventionRequired:
-                    tr.close()
-                    raise
-
-            # Ensure that we always end up on the latest version of the
-            # current changeset. Usually, this will be taken care of
-            # by the rebase operation. However, in some cases (such as
-            # if we are on the precursor of the base changeset) the
-            # rebase will not update to the latest version, so we need
-            # to do this manually.
-            successor = repo.revs('allsuccessors(.)').last()
-            if successor is not None:
-                commands.update(ui, repo, rev=successor)
+    # 1. Connect drafts via changelog
+    revs = list(repo.revs('(draft() & ::.)::'))
+    if not revs:
+        # "." is probably public. Check its direct children.
+        revs = repo.revs('draft() & children(.)')
+        if not revs:
+            # Be compatible with older restack, this is not an error
+            return
+    # 2. Connect revs via obsolete graph
+    revs = list(repo.revs('successors(%ld)+allpredecessors(%ld)', revs, revs))
+    # 3. Connect revs via changelog again to cover missing revs
+    revs = list(repo.revs('(draft() & ::%ld)::', revs))
 
-def _findrestacktargets(repo, base):
-    """Starting from the given base revision, do a BFS forwards through
-       history, looking for changesets with unstable descendants on their
-       precursors. Returns a list of any such changesets, in a top-down
-       ordering that will allow all of the descendants of their precursors
-       to be correctly rebased.
-    """
-    childrenof = common.getchildrelationships(repo,
-        repo.revs('%d + allpredecessors(%d)', base, base))
+    rebaseopts['rev'] = [revsetlang.formatspec('%ld', revs)]
+    rebaseopts['dest'] = '_destrestack(SRC)'
 
-    # Perform BFS starting from base.
-    queue = deque([base])
-    targets = []
-    processed = set()
-    while queue:
-        rev = queue.popleft()
+    # TODO: Remove config override after https://phab.mercurial-scm.org/D1063
+    config = {('experimental', 'rebase.multidest'): True}
 
-        # Merges may result in the same revision being added to the queue
-        # multiple times. Filter those cases out.
-        if rev in processed:
-            continue
-
-        processed.add(rev)
+    with ui.configoverride(config), repo.wlock(), repo.lock():
+        rebase.rebase(ui, repo, **rebaseopts)
 
-        # Children need to be added in sorted order so that newer
-        # children (as determined by rev number) will have their
-        # descendants of their precursors rebased before older children.
-        # This ensures that unstable changesets will always be rebased
-        # onto the latest visible successor of their parent changeset.
-        queue.extend(sorted(childrenof[rev]))
-
-        # Look for visible precursors (which are probably visible because
-        # they have unstable descendants) and successors (for which the latest
-        # non-obsolete version should be visible).
-        precursors = repo.revs('allpredecessors(%d)', rev)
-        successors = repo.revs('allsuccessors(%d)', rev)
-
-        # If this changeset has precursors but no successor, then
-        # if its precursors have children those children need to be
-        # rebased onto the changeset.
-        if precursors and not successors:
-            children = []
-            for p in precursors:
-                children.extend(childrenof[p])
-            if children:
-                queue.extend(children)
-                targets.append(rev)
-
-    # We need to perform the rebases in reverse-BFS order so that
-    # obsolescence information at lower levels is not modified by rebases
-    # at higher levels.
-    return reversed(targets)
+        # Ensure that we always end up on the latest version of the
+        # current changeset. Usually, this will be taken care of
+        # by the rebase operation. However, in some cases (such as
+        # if we are on the precursor of the base changeset) the
+        # rebase will not update to the latest version, so we need
+        # to do this manually.
+        successor = repo.revs('allsuccessors(.)').last()
+        if successor is not None:
+            commands.update(ui, repo, rev=successor)
diff --git a/hgext3rd/fbamend/revsets.py b/hgext3rd/fbamend/revsets.py
--- a/hgext3rd/fbamend/revsets.py
+++ b/hgext3rd/fbamend/revsets.py
@@ -7,8 +7,10 @@
 
 from __future__ import absolute_import
 
+from mercurial.node import nullrev
 from mercurial import (
     obsutil,
+    phases,
     registrar,
     revset,
     smartset,
@@ -59,3 +61,57 @@
     """All changesets which are predecessors for given set, recursively"""
     f = lambda nodes: obsutil.allpredecessors(repo.obsstore, nodes)
     return _calculateset(repo, subset, x, f)
+
+_successorsetscache = {}
+
+@revsetpredicate('_destrestack(SRC)')
+def _destrestack(repo, subset, x):
+    """restack destination for given single source revision"""
+    unfi = repo.unfiltered()
+    obsoleted = unfi.revs('obsolete()')
+    getparents = unfi.changelog.parentrevs
+    getphase = unfi._phasecache.phase
+    nodemap = unfi.changelog.nodemap
+
+    src = revset.getset(repo, subset, x).first()
+
+    # Empty src or already obsoleted - Do not return a destination
+    if not src or src in obsoleted:
+        return smartset.baseset()
+
+    # Find the obsoleted "base" by checking source's parent recursively
+    base = src
+    while base not in obsoleted:
+        base = getparents(base)[0]
+        # When encountering a public revision which cannot be obsoleted, stop
+        # the search early and return no destination. Do the same for nullrev.
+        if getphase(repo, base) == phases.public or base == nullrev:
+            return smartset.baseset()
+
+    # Find successors for given base
+    # NOTE: Ideally we can use obsutil.successorssets to detect divergence
+    # case. However it does not support cycles (unamend) well. So we use
+    # allsuccessors and pick non-obsoleted successors manually as a workaround.
+    basenode = repo[base].node()
+    succnodes = [n for n in obsutil.allsuccessors(repo.obsstore, [basenode])
+                 if (n != basenode and n in nodemap
+                     and nodemap[n] not in obsoleted)]
+
+    # in case of a split, only keep its heads
+    succrevs = list(unfi.revs('heads(%ln)', succnodes))
+
+    if len(succrevs) == 0:
+        # Prune - Find the first non-obsoleted ancestor
+        while base in obsoleted:
+            base = getparents(base)[0]
+            if base == nullrev:
+                return smartset.baseset()
+        return smartset.baseset([base])
+    elif len(succrevs) == 1:
+        # Unique visible successor case - A valid destination
+        return smartset.baseset([succrevs[0]])
+    else:
+        # Multiple visible successors - Choose the one with a greater revision
+        # number. This is to be compatible with restack old behavior. We might
+        # want to revisit it when we introduce the divergence concept to users.
+        return smartset.baseset([max(succrevs)])
diff --git a/tests/test-copytrace-amend.t b/tests/test-copytrace-amend.t
--- a/tests/test-copytrace-amend.t
+++ b/tests/test-copytrace-amend.t
@@ -207,12 +207,11 @@
   rebasing 2:ad25e018afa9 "mod a"
   merging b and a to b
   rebasing 3:ba0395f0e180 "delete a"
-  transaction abort!
-  rollback completed
   abort: a@ba0395f0e180: not found in manifest!
   [255]
   $ hg rebase --abort
-  rebase aborted (no revision is removed, only broken state is cleared)
+  saved backup bundle to $TESTTMP/repo/.hg/strip-backup/3fd0353a7967-a25c7d46-backup.hg (glob)
+  rebase aborted
   $ cd ..
   $ rm -rf repo
 
diff --git a/tests/test-fbamend-restack.t b/tests/test-fbamend-restack.t
--- a/tests/test-fbamend-restack.t
+++ b/tests/test-fbamend-restack.t
@@ -341,13 +341,12 @@
   |/
   o  0 add a
   $ hg rebase --restack
+  rebasing 5:a43fcd08f41f "add c" (tip)
   rebasing 3:47d2a3944de8 "add d"
-  rebasing 5:a43fcd08f41f "add c" (tip)
-  rebasing 6:49b119a57122 "add d"
   $ showgraph
-  @  8 add d
+  @  7 add d
   |
-  o  7 add c
+  o  6 add c
   |
   o  4 add b
   |
@@ -521,28 +520,22 @@
   |/
   o  0 add a
   $ hg unamend
-  $ hg up -C 1
+  $ hg up -C 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ showgraph
-  o  3 add b
+  @  3 add b
   |
   | o  2 add c
   | |
-  | @  1 add b
-  |/
-  o  0 add a
-  $ hg rebase --restack
-  rebasing 2:4538525df7e2 "add c"
-  1 files updated, 0 files merged, 0 files removed, 0 files unresolved
-  $ showgraph
-  o  5 add c
-  |
-  @  3 add b
-  |
   | o  1 add b
   |/
   o  0 add a
 
+Revision 2 "add c" is already stable (not orphaned) so restack does nothing:
+
+  $ hg rebase --restack
+  nothing to rebase - empty destination
+
 Test recursive restacking -- basic case.
   $ reset
   $ mkcommit a
@@ -576,14 +569,13 @@
   |/
   o  0 add a
   $ hg rebase --restack
+  rebasing 5:a43fcd08f41f "add c" (tip)
   rebasing 3:47d2a3944de8 "add d"
-  rebasing 5:a43fcd08f41f "add c" (tip)
-  rebasing 6:49b119a57122 "add d"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ showgraph
-  o  8 add d
+  o  7 add d
   |
-  o  7 add c
+  o  6 add c
   |
   @  4 add b
   |
@@ -657,24 +649,22 @@
   |/
   o  0 add a
   $ hg rebase --restack
-  rebasing 10:9f2a7cefd4b4 "add h"
   rebasing 6:2a79e3a98cd6 "add f"
-  rebasing 3:47d2a3944de8 "add d"
   rebasing 8:a43fcd08f41f "add c"
   rebasing 11:604f34a1983d "add g" (tip)
-  rebasing 12:e1df23499b99 "add h"
-  rebasing 14:49b119a57122 "add d"
+  rebasing 3:47d2a3944de8 "add d"
+  rebasing 10:9f2a7cefd4b4 "add h"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ showgraph
-  o  18 add d
+  o  16 add h
   |
-  | o  17 add h
+  | o  15 add d
   | |
-  | o  16 add g
+  o |  14 add g
   |/
-  o  15 add c
+  o  13 add c
   |
-  | o  13 add f
+  | o  12 add f
   | |
   | o  7 add e
   |/
@@ -684,7 +674,7 @@
   |/
   o  0 add a
 
-Suboptimal case: restack rebases "D" twice
+Restack does topological sort and only rebases "D" once:
 
   $ reset
   $ hg debugdrawdag<<'EOS'
@@ -717,13 +707,12 @@
   |/
   o  0 A
   $ hg rebase --restack
+  rebasing 5:ca53c8ceb284 "C"
   rebasing 3:f585351a92f8 "D" (D)
-  rebasing 5:ca53c8ceb284 "C"
-  rebasing 7:4da953fe10f3 "D"
   $ showgraph
-  o  9 D
+  o  8 D
   |
-  o  8 C
+  o  7 C
   |
   @  6 B3
   |
@@ -736,3 +725,54 @@
   | x  1 B
   |/
   o  0 A
+
+Restack will only restack the "current" stack and leave other stacks untouched.
+
+  $ reset
+  $ hg debugdrawdag<<'EOS'
+  >  D   H   K
+  >  |   |   |
+  >  B C F G J L    # amend: B -> C
+  >  |/  |/  |/     # amend: F -> G
+  >  A   E   I   Z  # amend: J -> L
+  > EOS
+
+  $ hg phase --public -r Z+I+A+E
+
+  $ hg update -q Z
+  $ hg rebase --restack
+
+  $ hg update -q D
+  $ hg rebase --restack
+  rebasing 10:be0ef73c17ad "D" (D)
+
+  $ hg update -q G
+  $ hg rebase --restack
+  rebasing 11:cc209258a732 "H" (H)
+
+  $ hg update -q I
+  $ hg rebase --restack
+  rebasing 12:59760668f0e1 "K" (K)
+
+  $ rm .hg/localtags
+  $ showgraph
+  o  15 K
+  |
+  | o  14 H
+  | |
+  | | o  13 D
+  | | |
+  o | |  9 L
+  | | |
+  | o |  7 G
+  | | |
+  | | o  5 C
+  | | |
+  | | | o  3 Z
+  | | |
+  @ | |  2 I
+   / /
+  o /  1 E
+   /
+  o  0 A
+