diff --git a/SOURCES/0421-core-reinstate-propagation-of-stop-restart-jobs-via-.patch b/SOURCES/0421-core-reinstate-propagation-of-stop-restart-jobs-via-.patch
new file mode 100644
index 0000000..0fa7815
--- /dev/null
+++ b/SOURCES/0421-core-reinstate-propagation-of-stop-restart-jobs-via-.patch
@@ -0,0 +1,84 @@
+From c552d788919808b1279bc42c9cd4b9e69878f4da Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Tue, 19 May 2015 17:40:50 +0200
+Subject: [PATCH] core: reinstate propagation of stop/restart jobs via
+ RequsiteOf dependencies
+
+This reverts the primary effect of be7d9ff730cb88d7c6a869dd5c47754c78ceaef2.
+
+After all Requisite= should be close to Requires=, without the one
+exception that it doesn't pull in dependencies on start. However,
+reverse deps on stop/restart should be treated the same way as for
+Restart=, and this is already documented in the man page, hence stick to
+it.
+
+http://lists.freedesktop.org/archives/systemd-devel/2015-May/032049.html
+(cherry picked from commit ce74e76920dca603a12ef4bf605567965e9e7e45)
+
+[msekleta: we didn't backport be7d9ff730cb88d7c6a869dd5c47754c78ceaef2
+and hence we don't have UNIT_REQUISITE_OF. Note that this patch was
+backported because it makes backports of followup patches easier]
+
+Related: #1436021
+---
+ src/core/transaction.c | 41 +++++++++++++----------------------------
+ 1 file changed, 13 insertions(+), 28 deletions(-)
+
+diff --git a/src/core/transaction.c b/src/core/transaction.c
+index 57e9cb3..428b767 100644
+--- a/src/core/transaction.c
++++ b/src/core/transaction.c
+@@ -1008,40 +1008,25 @@ int transaction_add_job_and_dependencies(
+                 }
+ 
+                 if (type == JOB_STOP || type == JOB_RESTART) {
++                        static const UnitDependency propagate_deps[] = {
++                                UNIT_REQUIRED_BY,
++                                UNIT_BOUND_BY,
++                                UNIT_CONSISTS_OF,
++                        };
+ 
+-                        SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i) {
+-                                r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
+-                                if (r < 0) {
+-                                        if (r != -EBADR)
+-                                                goto fail;
+-
+-                                        if (e)
+-                                                sd_bus_error_free(e);
+-                                }
+-                        }
+-
+-                        SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i) {
+-                                r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
+-                                if (r < 0) {
+-                                        if (r != -EBADR)
+-                                                goto fail;
++                        unsigned j;
+ 
+-                                        if (e)
+-                                                sd_bus_error_free(e);
+-                                }
+-                        }
++                        for (j = 0; j < ELEMENTSOF(propagate_deps); j++)
++                                SET_FOREACH(dep, ret->unit->dependencies[propagate_deps[j]], i) {
+ 
+-                        SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONSISTS_OF], i) {
+-                                r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
+-                                if (r < 0) {
+-                                        if (r != -EBADR)
+-                                                goto fail;
++                                        r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
++                                        if (r < 0) {
++                                                if (r != -EBADR)
++                                                        goto fail;
+ 
+-                                        if (e)
+                                                 sd_bus_error_free(e);
++                                        }
+                                 }
+-                        }
+-
+                 }
+ 
+                 if (type == JOB_RELOAD) {
diff --git a/SOURCES/0422-core-when-propagating-restart-requests-due-to-deps-d.patch b/SOURCES/0422-core-when-propagating-restart-requests-due-to-deps-d.patch
new file mode 100644
index 0000000..f228bd6
--- /dev/null
+++ b/SOURCES/0422-core-when-propagating-restart-requests-due-to-deps-d.patch
@@ -0,0 +1,142 @@
+From 936aef312eb93eb84a872cae4e3cc98b7ac9305c Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Tue, 19 May 2015 18:13:22 +0200
+Subject: [PATCH] core: when propagating restart requests due to deps,
+ downgrade restart to try-restart
+
+Previously, if a service A depended on a service B via Requires=, and A
+was not running and B restarted this would trigger a start of A as well,
+since the restart was propagated as restart independently of the state
+of A.
+
+This patch ensures that a restart of B would be propagated as a
+try-restart to A, thus not changing its state if it isn't up.
+
+http://lists.freedesktop.org/archives/systemd-devel/2015-May/032061.html
+(cherry picked from commit c6497ccb7153af9a1252c48918e380b5134314de)
+
+Resolves: #1436021
+---
+ src/core/job.c         | 28 ++++++++++++++--------------
+ src/core/job.h         |  2 +-
+ src/core/manager.c     |  2 +-
+ src/core/transaction.c | 11 ++++++++---
+ 4 files changed, 24 insertions(+), 19 deletions(-)
+
+diff --git a/src/core/job.c b/src/core/job.c
+index c2876de..e2b7375 100644
+--- a/src/core/job.c
++++ b/src/core/job.c
+@@ -392,38 +392,38 @@ bool job_type_is_redundant(JobType a, UnitActiveState b) {
+         }
+ }
+ 
+-void job_type_collapse(JobType *t, Unit *u) {
++JobType job_type_collapse(JobType t, Unit *u) {
+         UnitActiveState s;
+ 
+-        switch (*t) {
++        switch (t) {
+ 
+         case JOB_TRY_RESTART:
+                 s = unit_active_state(u);
+                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
+-                        *t = JOB_NOP;
+-                else
+-                        *t = JOB_RESTART;
+-                break;
++                        return JOB_NOP;
++
++                return JOB_RESTART;
+ 
+         case JOB_RELOAD_OR_START:
+                 s = unit_active_state(u);
+                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
+-                        *t = JOB_START;
+-                else
+-                        *t = JOB_RELOAD;
+-                break;
++                        return JOB_START;
++
++                return JOB_RELOAD;
+ 
+         default:
+-                ;
++                return t;
+         }
+ }
+ 
+ int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) {
+-        JobType t = job_type_lookup_merge(*a, b);
++        JobType t;
++
++        t = job_type_lookup_merge(*a, b);
+         if (t < 0)
+                 return -EEXIST;
+-        *a = t;
+-        job_type_collapse(a, u);
++
++        *a = job_type_collapse(t, u);
+         return 0;
+ }
+ 
+diff --git a/src/core/job.h b/src/core/job.h
+index e4191ee..ce81607 100644
+--- a/src/core/job.h
++++ b/src/core/job.h
+@@ -210,7 +210,7 @@ bool job_type_is_redundant(JobType a, UnitActiveState b) _pure_;
+ 
+ /* Collapses a state-dependent job type into a simpler type by observing
+  * the state of the unit which it is going to be applied to. */
+-void job_type_collapse(JobType *t, Unit *u);
++JobType job_type_collapse(JobType t, Unit *u);
+ 
+ int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u);
+ 
+diff --git a/src/core/manager.c b/src/core/manager.c
+index 6d045fd..329e0bf 100644
+--- a/src/core/manager.c
++++ b/src/core/manager.c
+@@ -1303,7 +1303,7 @@ int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool ove
+                        "Trying to enqueue job %s/%s/%s", unit->id,
+                        job_type_to_string(type), job_mode_to_string(mode));
+ 
+-        job_type_collapse(&type, unit);
++        type = job_type_collapse(type, unit);
+ 
+         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
+         if (!tr)
+diff --git a/src/core/transaction.c b/src/core/transaction.c
+index 428b767..34df157 100644
+--- a/src/core/transaction.c
++++ b/src/core/transaction.c
+@@ -855,8 +855,7 @@ int transaction_add_job_and_dependencies(
+         /*           by ? job_type_to_string(by->type) : "NA"); */
+ 
+         if (!IN_SET(unit->load_state, UNIT_LOADED, UNIT_ERROR, UNIT_NOT_FOUND, UNIT_MASKED))
+-                return sd_bus_error_setf(e, BUS_ERROR_LOAD_FAILED,
+-                                         "Unit %s is not loaded properly.", unit->id);
++                return sd_bus_error_setf(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
+ 
+         if (type != JOB_STOP) {
+                 r = bus_unit_check_load_state(unit, e);
+@@ -1014,12 +1013,18 @@ int transaction_add_job_and_dependencies(
+                                 UNIT_CONSISTS_OF,
+                         };
+ 
++                        JobType ptype;
+                         unsigned j;
+ 
++                        /* We propagate STOP as STOP, but RESTART only
++                         * as TRY_RESTART, in order not to start
++                         * dependencies that are not around. */
++                        ptype = type == JOB_RESTART ? JOB_TRY_RESTART : type;
++
+                         for (j = 0; j < ELEMENTSOF(propagate_deps); j++)
+                                 SET_FOREACH(dep, ret->unit->dependencies[propagate_deps[j]], i) {
+ 
+-                                        r = transaction_add_job_and_dependencies(tr, type, dep, ret, true, override, false, false, ignore_order, e);
++                                        r = transaction_add_job_and_dependencies(tr, job_type_collapse(ptype, dep), dep, ret, true, override, false, false, ignore_order, e);
+                                         if (r < 0) {
+                                                 if (r != -EBADR)
+                                                         goto fail;
diff --git a/SOURCES/0423-core-properly-handle-jobs-that-are-suppressed-to-JOB.patch b/SOURCES/0423-core-properly-handle-jobs-that-are-suppressed-to-JOB.patch
new file mode 100644
index 0000000..96c2229
--- /dev/null
+++ b/SOURCES/0423-core-properly-handle-jobs-that-are-suppressed-to-JOB.patch
@@ -0,0 +1,31 @@
+From 4179d6e6796a65738e9859a9e60c82f5c7573497 Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Thu, 21 May 2015 20:39:23 +0200
+Subject: [PATCH] core: properly handle jobs that are suppressed to JOB_NOPs
+ when propagating restarts
+
+Cherry-picked from: 48894cd0
+Resolves: #1436021
+---
+ src/core/transaction.c | 7 ++++++-
+ 1 file changed, 6 insertions(+), 1 deletion(-)
+
+diff --git a/src/core/transaction.c b/src/core/transaction.c
+index 34df157..66bbb60 100644
+--- a/src/core/transaction.c
++++ b/src/core/transaction.c
+@@ -1023,8 +1023,13 @@ int transaction_add_job_and_dependencies(
+ 
+                         for (j = 0; j < ELEMENTSOF(propagate_deps); j++)
+                                 SET_FOREACH(dep, ret->unit->dependencies[propagate_deps[j]], i) {
++                                        JobType nt;
+ 
+-                                        r = transaction_add_job_and_dependencies(tr, job_type_collapse(ptype, dep), dep, ret, true, override, false, false, ignore_order, e);
++                                        nt = job_type_collapse(ptype, dep);
++                                        if (nt == JOB_NOP)
++                                                continue;
++
++                                        r = transaction_add_job_and_dependencies(tr, nt, dep, ret, true, override, false, false, ignore_order, e);
+                                         if (r < 0) {
+                                                 if (r != -EBADR)
+                                                         goto fail;
diff --git a/SPECS/systemd.spec b/SPECS/systemd.spec
index 0ea46e0..e16fce3 100644
--- a/SPECS/systemd.spec
+++ b/SPECS/systemd.spec
@@ -7,7 +7,7 @@
 Name:           systemd
 Url:            http://www.freedesktop.org/wiki/Software/systemd
 Version:        219
-Release:        30%{?dist}.8
+Release:        30%{?dist}.9
 # For a breakdown of the licensing, see README
 License:        LGPLv2+ and MIT and GPLv2+
 Summary:        A System and Service Manager
@@ -455,6 +455,9 @@ Patch0417: 0417-load-fragment-fix-parsing-values-in-bytes-and-preven.patch
 Patch0418: 0418-core-fix-assertion-check.patch
 Patch0419: 0419-tmp.mount.hm4-After-swap.target-3087.patch
 Patch0420: 0420-make-sure-all-swap-units-are-ordered-before-the-swap.patch
+Patch0421: 0421-core-reinstate-propagation-of-stop-restart-jobs-via-.patch
+Patch0422: 0422-core-when-propagating-restart-requests-due-to-deps-d.patch
+Patch0423: 0423-core-properly-handle-jobs-that-are-suppressed-to-JOB.patch
 
 
 %global num_patches %{lua: c=0; for i,p in ipairs(patches) do c=c+1; end; print(c);}
@@ -1463,6 +1466,11 @@ fi
 %{_mandir}/man8/systemd-resolved.*
 
 %changelog
+* Fri Apr 21 2017 Lukas Nykryn <lnykryn@redhat.com> - 219-30.9
+- core: reinstate propagation of stop/restart jobs via RequsiteOf dependencies (#1436021)
+- core: when propagating restart requests due to deps, downgrade restart to try-restart (#1436021)
+- core: properly handle jobs that are suppressed to JOB_NOPs when propagating restarts (#1436021)
+
 * Mon Feb 13 2017 Lukas Nykryn <lnykryn@redhat.com> - 219-30.8
 - tmp.mount.hm4: After swap.target (#3087) (#1298355)
 - make sure all swap units are ordered before the swap target (#1298355)