diff --git a/include/crm/common/output_internal.h b/include/crm/common/output_internal.h
index e1bd295..1923c1a 100644
--- a/include/crm/common/output_internal.h
+++ b/include/crm/common/output_internal.h
@@ -648,9 +648,11 @@ pcmk__output_xml_add_node(pcmk__output_t *out, xmlNodePtr node);
  *
  * \param[in,out] out  The output functions structure.
  * \param[in]     name The name of the node to be created.
+ * \param[in]     ...     Name/value pairs to set as XML properties.
  */
 xmlNodePtr
-pcmk__output_create_xml_node(pcmk__output_t *out, const char *name);
+pcmk__output_create_xml_node(pcmk__output_t *out, const char *name, ...)
+G_GNUC_NULL_TERMINATED;
 
 /*!
  * \internal
diff --git a/lib/common/output_html.c b/lib/common/output_html.c
index e354b5d..77a5410 100644
--- a/lib/common/output_html.c
+++ b/lib/common/output_html.c
@@ -370,7 +370,7 @@ html_is_quiet(pcmk__output_t *out) {
 
 static void
 html_spacer(pcmk__output_t *out) {
-    pcmk__output_create_xml_node(out, "br");
+    pcmk__output_create_xml_node(out, "br", NULL);
 }
 
 pcmk__output_t *
diff --git a/lib/common/output_xml.c b/lib/common/output_xml.c
index 716d10f..80ee2de 100644
--- a/lib/common/output_xml.c
+++ b/lib/common/output_xml.c
@@ -24,6 +24,7 @@
 
 #include <crm/crm.h>
 #include <crm/common/xml.h>
+#include <crm/common/xml_internal.h>
 #include <crm/common/output_internal.h>
 
 static gboolean legacy_xml = FALSE;
@@ -234,16 +235,16 @@ xml_subprocess_output(pcmk__output_t *out, int exit_status,
 
 static void
 xml_version(pcmk__output_t *out, bool extended) {
-    xmlNodePtr node;
     private_data_t *priv = out->priv;
     CRM_ASSERT(priv != NULL);
 
-    node = pcmk__output_create_xml_node(out, "version");
-    xmlSetProp(node, (pcmkXmlStr) "program", (pcmkXmlStr) "Pacemaker");
-    xmlSetProp(node, (pcmkXmlStr) "version", (pcmkXmlStr) PACEMAKER_VERSION);
-    xmlSetProp(node, (pcmkXmlStr) "author", (pcmkXmlStr) "Andrew Beekhof");
-    xmlSetProp(node, (pcmkXmlStr) "build", (pcmkXmlStr) BUILD_VERSION);
-    xmlSetProp(node, (pcmkXmlStr) "features", (pcmkXmlStr) CRM_FEATURES);
+    pcmk__output_create_xml_node(out, "version",
+                                 "program", "Pacemaker",
+                                 "version", PACEMAKER_VERSION,
+                                 "author", "Andrew Beekhof",
+                                 "build", BUILD_VERSION,
+                                 "features", CRM_FEATURES,
+                                 NULL);
 }
 
 G_GNUC_PRINTF(2, 3)
@@ -277,7 +278,7 @@ xml_output_xml(pcmk__output_t *out, const char *name, const char *buf) {
 
     CRM_ASSERT(priv != NULL);
 
-    parent = pcmk__output_create_xml_node(out, name);
+    parent = pcmk__output_create_xml_node(out, name, NULL);
     cdata_node = xmlNewCDataBlock(getDocPtr(parent), (pcmkXmlStr) buf, strlen(buf));
     xmlAddChild(parent, cdata_node);
 }
@@ -419,7 +420,7 @@ pcmk__mk_xml_output(char **argv) {
 
 xmlNodePtr
 pcmk__output_xml_create_parent(pcmk__output_t *out, const char *name) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, name);
+    xmlNodePtr node = pcmk__output_create_xml_node(out, name, NULL);
     pcmk__output_xml_push_parent(out, node);
     return node;
 }
@@ -435,17 +436,24 @@ pcmk__output_xml_add_node(pcmk__output_t *out, xmlNodePtr node) {
 }
 
 xmlNodePtr
-pcmk__output_create_xml_node(pcmk__output_t *out, const char *name) {
+pcmk__output_create_xml_node(pcmk__output_t *out, const char *name, ...) {
+    xmlNodePtr node = NULL;
     private_data_t *priv = out->priv;
+    va_list args;
 
     CRM_ASSERT(priv != NULL);
 
-    return create_xml_node(g_queue_peek_tail(priv->parent_q), name);
+    node = create_xml_node(g_queue_peek_tail(priv->parent_q), name);
+    va_start(args, name);
+    pcmk__xe_set_propv(node, args);
+    va_end(args);
+
+    return node;
 }
 
 xmlNodePtr
 pcmk__output_create_xml_text_node(pcmk__output_t *out, const char *name, const char *content) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, name);
+    xmlNodePtr node = pcmk__output_create_xml_node(out, name, NULL);
     xmlNodeSetContent(node, (pcmkXmlStr) content);
     return node;
 }
diff --git a/lib/fencing/st_output.c b/lib/fencing/st_output.c
index c3b6b41..82520ee 100644
--- a/lib/fencing/st_output.c
+++ b/lib/fencing/st_output.c
@@ -132,10 +132,11 @@ stonith__full_history_xml(pcmk__output_t *out, va_list args) {
 
         PCMK__OUTPUT_LIST_FOOTER(out, rc);
     } else {
-        xmlNodePtr node = pcmk__output_create_xml_node(out, "fence_history");
         char *rc_s = crm_itoa(history_rc);
 
-        xmlSetProp(node, (pcmkXmlStr) "status", (pcmkXmlStr) rc_s);
+        pcmk__output_create_xml_node(out, "fence_history",
+                                     "status", rc_s,
+                                     NULL);
         free(rc_s);
 
         rc = pcmk_rc_ok;
@@ -182,11 +183,12 @@ stonith__last_fenced_xml(pcmk__output_t *out, va_list args) {
     time_t when = va_arg(args, time_t);
 
     if (when) {
-        xmlNodePtr node = pcmk__output_create_xml_node(out, "last-fenced");
         char *buf = time_t_string(when);
 
-        xmlSetProp(node, (pcmkXmlStr) "target", (pcmkXmlStr) target);
-        xmlSetProp(node, (pcmkXmlStr) "when", (pcmkXmlStr) buf);
+        pcmk__output_create_xml_node(out, "last-fenced",
+                                     "target", target,
+                                     "when", buf,
+                                     NULL);
 
         free(buf);
         return pcmk_rc_ok;
@@ -313,13 +315,19 @@ stonith__event_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("stonith-event", "stonith_history_t *", "gboolean", "gboolean")
 int
 stonith__event_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "fence_event");
     stonith_history_t *event = va_arg(args, stonith_history_t *);
     gboolean full_history G_GNUC_UNUSED = va_arg(args, gboolean);
     gboolean later_succeeded G_GNUC_UNUSED = va_arg(args, gboolean);
 
     char *buf = NULL;
 
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "fence_event",
+                                                   "action", event->action,
+                                                   "target", event->target,
+                                                   "client", event->client,
+                                                   "origin", event->origin,
+                                                   NULL);
+
     switch (event->state) {
         case st_failed:
             xmlSetProp(node, (pcmkXmlStr) "status", (pcmkXmlStr) "failed");
@@ -342,11 +350,6 @@ stonith__event_xml(pcmk__output_t *out, va_list args) {
         xmlSetProp(node, (pcmkXmlStr) "delegate", (pcmkXmlStr) event->delegate);
     }
 
-    xmlSetProp(node, (pcmkXmlStr) "action", (pcmkXmlStr) event->action);
-    xmlSetProp(node, (pcmkXmlStr) "target", (pcmkXmlStr) event->target);
-    xmlSetProp(node, (pcmkXmlStr) "client", (pcmkXmlStr) event->client);
-    xmlSetProp(node, (pcmkXmlStr) "origin", (pcmkXmlStr) event->origin);
-
     if (event->state == st_failed || event->state == st_done) {
         buf = time_t_string(event->completed);
         xmlSetProp(node, (pcmkXmlStr) "completed", (pcmkXmlStr) buf);
@@ -412,19 +415,20 @@ stonith__validate_agent_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("validate", "const char *", "const char *", "char *", "char *", "int")
 int
 stonith__validate_agent_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "validate");
-
     const char *agent = va_arg(args, const char *);
     const char *device = va_arg(args, const char *);
     char *output = va_arg(args, char *);
     char *error_output = va_arg(args, char *);
     int rc = va_arg(args, int);
 
-    xmlSetProp(node, (pcmkXmlStr) "agent", (pcmkXmlStr) agent);
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "validate",
+                                                   "agent", agent,
+                                                   "valid", pcmk__btoa(rc),
+                                                   NULL);
+
     if (device != NULL) {
         xmlSetProp(node, (pcmkXmlStr) "device", (pcmkXmlStr) device);
     }
-    xmlSetProp(node, (pcmkXmlStr) "valid", (pcmkXmlStr) pcmk__btoa(rc));
 
     pcmk__output_xml_push_parent(out, node);
     out->subprocess_output(out, rc, output, error_output);
diff --git a/lib/pacemaker/pcmk_output.c b/lib/pacemaker/pcmk_output.c
index fd577c6..08753fb 100644
--- a/lib/pacemaker/pcmk_output.c
+++ b/lib/pacemaker/pcmk_output.c
@@ -157,16 +157,15 @@ static int colocations_list_xml(pcmk__output_t *out, va_list args) {
 
         if (pcmk_is_set(peer->flags, pe_rsc_allocating)) {
             if (dependents == FALSE) {
-                xmlNodePtr node;
-
                 if (!printed_header) {
                     pcmk__output_xml_create_parent(out, "colocations");
                     printed_header = true;
                 }
 
-                node = pcmk__output_create_xml_node(out, "colocation");
-                xmlSetProp(node, (pcmkXmlStr) "peer", (pcmkXmlStr) peer->id);
-                xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) cons->id);
+                pcmk__output_create_xml_node(out, "colocation",
+                                             "peer", peer->id,
+                                             "id", cons->id,
+                                             NULL);
             }
             continue;
         }
@@ -187,18 +186,19 @@ static int colocations_list_xml(pcmk__output_t *out, va_list args) {
 
         score = score2char(cons->score);
         if (cons->role_rh > RSC_ROLE_STARTED) {
-            xmlNodePtr node = pcmk__output_create_xml_node(out, "colocation");
-            xmlSetProp(node, (pcmkXmlStr) "peer", (pcmkXmlStr) peer->id);
-            xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) cons->id);
-            xmlSetProp(node, (pcmkXmlStr) "score", (pcmkXmlStr) score);
-            xmlSetProp(node, (pcmkXmlStr) "dependents",
-                       (pcmkXmlStr) (dependents ? "needs" : "with"));
-            xmlSetProp(node, (pcmkXmlStr) "role", (pcmkXmlStr) role2text(cons->role_rh));
+            pcmk__output_create_xml_node(out, "colocation",
+                                         "peer", peer->id,
+                                         "id", cons->id,
+                                         "score", score,
+                                         "dependents", dependents ? "needs" : "with",
+                                         "role", role2text(cons->role_rh),
+                                         NULL);
         } else {
-            xmlNodePtr node = pcmk__output_create_xml_node(out, "colocation");
-            xmlSetProp(node, (pcmkXmlStr) "peer", (pcmkXmlStr) peer->id);
-            xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) cons->id);
-            xmlSetProp(node, (pcmkXmlStr) "score", (pcmkXmlStr) score);
+            pcmk__output_create_xml_node(out, "colocation",
+                                         "peer", peer->id,
+                                         "id", cons->id,
+                                         "score", score,
+                                         NULL);
         }
 
         free(score);
@@ -263,11 +263,11 @@ static int locations_list_xml(pcmk__output_t *out, va_list args) {
             pe_node_t *node = (pe_node_t *) lpc2->data;
             char *score = score2char(node->weight);
 
-            xmlNodePtr xml_node = pcmk__output_create_xml_node(out, "location");
-            xmlSetProp(xml_node, (pcmkXmlStr) "host", (pcmkXmlStr) node->details->uname);
-            xmlSetProp(xml_node, (pcmkXmlStr) "id", (pcmkXmlStr) cons->id);
-            xmlSetProp(xml_node, (pcmkXmlStr) "score", (pcmkXmlStr) score);
-
+            pcmk__output_create_xml_node(out, "location",
+                                         "host", node->details->uname,
+                                         "id", cons->id,
+                                         "score", score,
+                                         NULL);
             free(score);
         }
     }
@@ -385,11 +385,11 @@ health_xml(pcmk__output_t *out, va_list args)
     char *fsa_state = va_arg(args, char *);
     char *result = va_arg(args, char *);
 
-    xmlNodePtr node = pcmk__output_create_xml_node(out, crm_str(sys_from));
-    xmlSetProp(node, (pcmkXmlStr) "node_name", (pcmkXmlStr) crm_str(host_from));
-    xmlSetProp(node, (pcmkXmlStr) "state", (pcmkXmlStr) crm_str(fsa_state));
-    xmlSetProp(node, (pcmkXmlStr) "result", (pcmkXmlStr) crm_str(result));
-
+    pcmk__output_create_xml_node(out, crm_str(sys_from),
+                                 "node_name", crm_str(host_from),
+                                 "state", crm_str(fsa_state),
+                                 "result", crm_str(result),
+                                 NULL);
     return pcmk_rc_ok;
 }
 
@@ -420,11 +420,10 @@ pacemakerd_health_xml(pcmk__output_t *out, va_list args)
     char *state = va_arg(args, char *);
     char *last_updated = va_arg(args, char *);
 
-
-    xmlNodePtr node = pcmk__output_create_xml_node(out, crm_str(sys_from));
-    xmlSetProp(node, (pcmkXmlStr) "state", (pcmkXmlStr) crm_str(state));
-    xmlSetProp(node, (pcmkXmlStr) "last_updated", (pcmkXmlStr) crm_str(last_updated));
-
+    pcmk__output_create_xml_node(out, crm_str(sys_from),
+                                 "state", crm_str(state),
+                                 "last_updated", crm_str(last_updated),
+                                 NULL);
     return pcmk_rc_ok;
 }
 
@@ -449,9 +448,9 @@ dc_xml(pcmk__output_t *out, va_list args)
 {
     char *dc = va_arg(args, char *);
 
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "dc");
-    xmlSetProp(node, (pcmkXmlStr) "node_name", (pcmkXmlStr) crm_str(dc));
-
+    pcmk__output_create_xml_node(out, "dc",
+                                 "node_name", crm_str(dc),
+                                 NULL);
     return pcmk_rc_ok;
 }
 
@@ -517,11 +516,11 @@ crmadmin_node_xml(pcmk__output_t *out, va_list args)
     char *name = va_arg(args, char *);
     char *id = va_arg(args, char *);
 
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "node");
-    xmlSetProp(node, (pcmkXmlStr) "type", (pcmkXmlStr) (type ? type : "member"));
-    xmlSetProp(node, (pcmkXmlStr) "name", (pcmkXmlStr) crm_str(name));
-    xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) crm_str(id));
-
+    pcmk__output_create_xml_node(out, "node",
+                                 "type", type ? type : "member",
+                                 "name", crm_str(name),
+                                 "id", crm_str(id),
+                                 NULL);
     return pcmk_rc_ok;
 }
 
diff --git a/lib/pengine/bundle.c b/lib/pengine/bundle.c
index 4f6eac3..8a17aad 100644
--- a/lib/pengine/bundle.c
+++ b/lib/pengine/bundle.c
@@ -1663,7 +1663,7 @@ pe__bundle_html(pcmk__output_t *out, va_list args)
             }
 
             if (rc == pcmk_rc_no_output) {
-                pcmk__output_create_xml_node(out, "br");
+                pcmk__output_create_xml_node(out, "br", NULL);
             }
 
             PCMK__OUTPUT_LIST_HEADER(out, FALSE, rc, "Container bundle%s: %s [%s]%s%s",
@@ -1678,7 +1678,7 @@ pe__bundle_html(pcmk__output_t *out, va_list args)
                 snprintf(buffer, LINE_MAX, " Replica[%d]", replica->offset);
                 xmlNodeSetContent(pcmk__output_xml_peek_parent(out), (pcmkXmlStr) buffer);
             }
-            pcmk__output_create_xml_node(out, "br");
+            pcmk__output_create_xml_node(out, "br", NULL);
             out->begin_list(out, NULL, NULL, NULL);
 
             if (print_ip) {
diff --git a/lib/pengine/pe_output.c b/lib/pengine/pe_output.c
index b91348f..a6f5970 100644
--- a/lib/pengine/pe_output.c
+++ b/lib/pengine/pe_output.c
@@ -465,19 +465,19 @@ pe__ban_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("ban", "pe_node_t *", "pe__location_t *", "gboolean")
 int
 pe__ban_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "ban");
     pe_node_t *pe_node = va_arg(args, pe_node_t *);
     pe__location_t *location = va_arg(args, pe__location_t *);
     gboolean print_clone_detail G_GNUC_UNUSED = va_arg(args, gboolean);
 
     char *weight_s = crm_itoa(pe_node->weight);
 
-    xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) location->id);
-    xmlSetProp(node, (pcmkXmlStr) "resource", (pcmkXmlStr) location->rsc_lh->id);
-    xmlSetProp(node, (pcmkXmlStr) "node", (pcmkXmlStr) pe_node->details->uname);
-    xmlSetProp(node, (pcmkXmlStr) "weight", (pcmkXmlStr) weight_s);
-    xmlSetProp(node, (pcmkXmlStr) "master_only",
-               (pcmkXmlStr) pcmk__btoa(location->role_filter == RSC_ROLE_MASTER));
+    pcmk__output_create_xml_node(out, "ban",
+                                 "id", location->id,
+                                 "resource", location->rsc_lh->id,
+                                 "node", pe_node->details->uname,
+                                 "weight", weight_s,
+                                 "master_only", pcmk__btoa(location->role_filter == RSC_ROLE_MASTER),
+                                 NULL);
 
     free(weight_s);
     return pcmk_rc_ok;
@@ -486,8 +486,8 @@ pe__ban_xml(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-counts", "unsigned int", "int", "int", "int")
 int
 pe__cluster_counts_html(pcmk__output_t *out, va_list args) {
-    xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "li");
-    xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "li");
+    xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "li", NULL);
+    xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "li", NULL);
 
     unsigned int nnodes = va_arg(args, unsigned int);
     int nresources = va_arg(args, int);
@@ -582,8 +582,8 @@ pe__cluster_counts_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-counts", "unsigned int", "int", "int", "int")
 int
 pe__cluster_counts_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "nodes_configured");
-    xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "resources_configured");
+    xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "nodes_configured", NULL);
+    xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "resources_configured", NULL);
 
     unsigned int nnodes = va_arg(args, unsigned int);
     int nresources = va_arg(args, int);
@@ -612,7 +612,7 @@ pe__cluster_counts_xml(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-dc", "pe_node_t *", "const char *", "const char *", "char *")
 int
 pe__cluster_dc_html(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "li");
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
 
     pe_node_t *dc = va_arg(args, pe_node_t *);
     const char *quorum = va_arg(args, const char *);
@@ -665,22 +665,23 @@ pe__cluster_dc_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-dc", "pe_node_t *", "const char *", "const char *", "char *")
 int
 pe__cluster_dc_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "current_dc");
-
     pe_node_t *dc = va_arg(args, pe_node_t *);
     const char *quorum = va_arg(args, const char *);
     const char *dc_version_s = va_arg(args, const char *);
     char *dc_name G_GNUC_UNUSED = va_arg(args, char *);
 
     if (dc) {
-        xmlSetProp(node, (pcmkXmlStr) "present", (pcmkXmlStr) "true");
-        xmlSetProp(node, (pcmkXmlStr) "version", (pcmkXmlStr) (dc_version_s ? dc_version_s : ""));
-        xmlSetProp(node, (pcmkXmlStr) "name", (pcmkXmlStr) dc->details->uname);
-        xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) dc->details->id);
-        xmlSetProp(node, (pcmkXmlStr) "with_quorum",
-                   (pcmkXmlStr) pcmk__btoa(crm_is_true(quorum)));
+        pcmk__output_create_xml_node(out, "current_dc",
+                                     "present", "true",
+                                     "version", dc_version_s ? dc_version_s : "",
+                                     "name", dc->details->uname,
+                                     "id", dc->details->id,
+                                     "with_quorum", pcmk__btoa(crm_is_true(quorum)),
+                                     NULL);
     } else {
-        xmlSetProp(node, (pcmkXmlStr) "present", (pcmkXmlStr) "false");
+        pcmk__output_create_xml_node(out, "current_dc",
+                                     "present", "false",
+                                     NULL);
     }
 
     return pcmk_rc_ok;
@@ -741,14 +742,14 @@ pe__cluster_options_html(pcmk__output_t *out, va_list args) {
     }
 
     if (pcmk_is_set(data_set->flags, pe_flag_maintenance_mode)) {
-        xmlNodePtr node = pcmk__output_create_xml_node(out, "li");
+        xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
 
         pcmk_create_html_node(node, "span", NULL, NULL, "Resource management: ");
         pcmk_create_html_node(node, "span", NULL, "bold", "DISABLED");
         pcmk_create_html_node(node, "span", NULL, NULL,
                               " (the cluster will not attempt to start, stop, or recover services)");
     } else if (pcmk_is_set(data_set->flags, pe_flag_stop_everything)) {
-        xmlNodePtr node = pcmk__output_create_xml_node(out, "li");
+        xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
 
         pcmk_create_html_node(node, "span", NULL, NULL, "Resource management: ");
         pcmk_create_html_node(node, "span", NULL, "bold", "STOPPED");
@@ -817,48 +818,45 @@ pe__cluster_options_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-options", "pe_working_set_t *")
 int
 pe__cluster_options_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "cluster_options");
     pe_working_set_t *data_set = va_arg(args, pe_working_set_t *);
-
-    xmlSetProp(node, (pcmkXmlStr) "stonith-enabled",
-               (pcmkXmlStr) pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)));
-    xmlSetProp(node, (pcmkXmlStr) "symmetric-cluster",
-               (pcmkXmlStr) pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_symmetric_cluster)));
+    const char *no_quorum_policy = NULL;
 
     switch (data_set->no_quorum_policy) {
         case no_quorum_freeze:
-            xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "freeze");
+            no_quorum_policy = "freeze";
             break;
 
         case no_quorum_stop:
-            xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "stop");
+            no_quorum_policy = "stop";
             break;
 
         case no_quorum_demote:
-            xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "demote");
+            no_quorum_policy = "demote";
             break;
 
         case no_quorum_ignore:
-            xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "ignore");
+            no_quorum_policy = "ignore";
             break;
 
         case no_quorum_suicide:
-            xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "suicide");
+            no_quorum_policy = "suicide";
             break;
     }
 
-    xmlSetProp(node, (pcmkXmlStr) "maintenance-mode",
-               (pcmkXmlStr) pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_maintenance_mode)));
-    xmlSetProp(node, (pcmkXmlStr) "stop-all-resources",
-               (pcmkXmlStr) pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_stop_everything)));
-
+    pcmk__output_create_xml_node(out, "cluster_options",
+                                 "stonith-enabled", pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)),
+                                 "symmetric-cluster", pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_symmetric_cluster)),
+                                 "no-quorum-policy", no_quorum_policy,
+                                 "maintenance-mode", pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_maintenance_mode)),
+                                 "stop-all-resources", pcmk__btoa(pcmk_is_set(data_set->flags, pe_flag_stop_everything)),
+                                 NULL);
     return pcmk_rc_ok;
 }
 
 PCMK__OUTPUT_ARGS("cluster-stack", "const char *")
 int
 pe__cluster_stack_html(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "li");
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
     const char *stack_s = va_arg(args, const char *);
 
     pcmk_create_html_node(node, "span", NULL, "bold", "Stack: ");
@@ -878,10 +876,11 @@ pe__cluster_stack_text(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-stack", "const char *")
 int
 pe__cluster_stack_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "stack");
     const char *stack_s = va_arg(args, const char *);
 
-    xmlSetProp(node, (pcmkXmlStr) "type", (pcmkXmlStr) stack_s);
+    pcmk__output_create_xml_node(out, "stack",
+                                 "type", stack_s,
+                                 NULL);
 
     return pcmk_rc_ok;
 }
@@ -889,8 +888,8 @@ pe__cluster_stack_xml(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-times", "const char *", "const char *", "const char *", "const char *")
 int
 pe__cluster_times_html(pcmk__output_t *out, va_list args) {
-    xmlNodePtr updated_node = pcmk__output_create_xml_node(out, "li");
-    xmlNodePtr changed_node = pcmk__output_create_xml_node(out, "li");
+    xmlNodePtr updated_node = pcmk__output_create_xml_node(out, "li", NULL);
+    xmlNodePtr changed_node = pcmk__output_create_xml_node(out, "li", NULL);
 
     const char *last_written = va_arg(args, const char *);
     const char *user = va_arg(args, const char *);
@@ -913,20 +912,20 @@ pe__cluster_times_html(pcmk__output_t *out, va_list args) {
 PCMK__OUTPUT_ARGS("cluster-times", "const char *", "const char *", "const char *", "const char *")
 int
 pe__cluster_times_xml(pcmk__output_t *out, va_list args) {
-    xmlNodePtr updated_node = pcmk__output_create_xml_node(out, "last_update");
-    xmlNodePtr changed_node = pcmk__output_create_xml_node(out, "last_change");
-
     const char *last_written = va_arg(args, const char *);
     const char *user = va_arg(args, const char *);
     const char *client = va_arg(args, const char *);
     const char *origin = va_arg(args, const char *);
 
-    xmlSetProp(updated_node, (pcmkXmlStr) "time",
-               (pcmkXmlStr) pcmk__epoch2str(NULL));
-    xmlSetProp(changed_node, (pcmkXmlStr) "time", (pcmkXmlStr) (last_written ? last_written : ""));
-    xmlSetProp(changed_node, (pcmkXmlStr) "user", (pcmkXmlStr) (user ? user : ""));
-    xmlSetProp(changed_node, (pcmkXmlStr) "client", (pcmkXmlStr) (client ? client : ""));
-    xmlSetProp(changed_node, (pcmkXmlStr) "origin", (pcmkXmlStr) (origin ? origin : ""));
+    pcmk__output_create_xml_node(out, "last_update",
+                                 "time", pcmk__epoch2str(NULL),
+                                 NULL);
+    pcmk__output_create_xml_node(out, "last_change",
+                                 "time", last_written ? last_written : "",
+                                 "user", user ? user : "",
+                                 "client", client ? client : "",
+                                 "origin", origin ? origin : "",
+                                 NULL);
 
     return pcmk_rc_ok;
 }
@@ -972,20 +971,15 @@ pe__failed_action_xml(pcmk__output_t *out, va_list args) {
 
     char *rc_s = crm_itoa(rc);
     char *reason_s = crm_xml_escape(exit_reason ? exit_reason : "none");
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "failure");
-
-    xmlSetProp(node, (pcmkXmlStr) (op_key ? "op_key" : "id"),
-               (pcmkXmlStr) (op_key ? op_key : ID(xml_op)));
-    xmlSetProp(node, (pcmkXmlStr) "node",
-               (pcmkXmlStr) crm_element_value(xml_op, XML_ATTR_UNAME));
-    xmlSetProp(node, (pcmkXmlStr) "exitstatus",
-               (pcmkXmlStr) services_ocf_exitcode_str(rc));
-    xmlSetProp(node, (pcmkXmlStr) "exitreason", (pcmkXmlStr) reason_s);
-    xmlSetProp(node, (pcmkXmlStr) "exitcode", (pcmkXmlStr) rc_s);
-    xmlSetProp(node, (pcmkXmlStr) "call",
-               (pcmkXmlStr) crm_element_value(xml_op, XML_LRM_ATTR_CALLID));
-    xmlSetProp(node, (pcmkXmlStr) "status",
-               (pcmkXmlStr) services_lrm_status_str(status));
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "failure",
+                                                   op_key ? "op_key" : "id", op_key ? op_key : ID(xml_op),
+                                                   "node", crm_element_value(xml_op, XML_ATTR_UNAME),
+                                                   "exitstatus", services_ocf_exitcode_str(rc),
+                                                   "exitreason", reason_s,
+                                                   "exitcode", rc_s,
+                                                   "call", crm_element_value(xml_op, XML_LRM_ATTR_CALLID),
+                                                   "status", services_lrm_status_str(status),
+                                                   NULL);
 
     if (last) {
         guint interval_ms = 0;
@@ -1037,7 +1031,7 @@ pe__node_html(pcmk__output_t *out, va_list args) {
     char *buf = crm_strdup_printf("Node: %s", node_name);
 
     if (full) {
-        xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li");
+        xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li", NULL);
 
         pcmk_create_html_node(item_node, "span", NULL, NULL, buf);
 
@@ -1265,7 +1259,7 @@ pe__node_attribute_html(pcmk__output_t *out, va_list args) {
     if (add_extra) {
         int v = crm_parse_int(value, "0");
         char *s = crm_strdup_printf("%s: %s", name, value);
-        xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li");
+        xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li", NULL);
 
         pcmk_create_html_node(item_node, "span", NULL, NULL, s);
         free(s);
@@ -1351,7 +1345,13 @@ pe__node_and_op_xml(pcmk__output_t *out, va_list args) {
     int status = crm_parse_int(status_s, "0");
     time_t last_change = 0;
 
-    xmlNode *node = pcmk__output_create_xml_node(out, "operation");
+    xmlNode *node = pcmk__output_create_xml_node(out, "operation",
+                                                 "op", op_key ? op_key : ID(xml_op),
+                                                 "node", crm_element_value(xml_op, XML_ATTR_UNAME),
+                                                 "call", crm_element_value(xml_op, XML_LRM_ATTR_CALLID),
+                                                 "rc", crm_element_value(xml_op, XML_LRM_ATTR_RC),
+                                                 "status", services_lrm_status_str(status),
+                                                 NULL);
 
     rsc = pe_find_resource(data_set->resources, op_rsc);
 
@@ -1382,8 +1382,6 @@ pe__node_and_op_xml(pcmk__output_t *out, va_list args) {
                    (pcmkXmlStr) crm_element_value(xml_op, XML_RSC_OP_T_EXEC));
     }
 
-    xmlSetProp(node, (pcmkXmlStr) "status", (pcmkXmlStr) services_lrm_status_str(status));
-
     return pcmk_rc_ok;
 }
 
@@ -1395,9 +1393,10 @@ pe__node_attribute_xml(pcmk__output_t *out, va_list args) {
     gboolean add_extra = va_arg(args, gboolean);
     int expected_score = va_arg(args, int);
 
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "attribute");
-    xmlSetProp(node, (pcmkXmlStr) "name", (pcmkXmlStr) name);
-    xmlSetProp(node, (pcmkXmlStr) "value", (pcmkXmlStr) value);
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "attribute",
+                                                   "name", name,
+                                                   "value", value,
+                                                   NULL);
 
     if (add_extra) {
         char *buf = crm_itoa(expected_score);
@@ -1630,13 +1629,14 @@ pe__op_history_xml(pcmk__output_t *out, va_list args) {
     int rc = va_arg(args, int);
     gboolean print_timing = va_arg(args, gboolean);
 
-    char *rc_s = NULL;
-
-    xmlNodePtr node = pcmk__output_create_xml_node(out, "operation_history");
-
-    xmlSetProp(node, (pcmkXmlStr) "call",
-               (pcmkXmlStr) crm_element_value(xml_op, XML_LRM_ATTR_CALLID));
-    xmlSetProp(node, (pcmkXmlStr) "task", (pcmkXmlStr) task);
+    char *rc_s = crm_itoa(rc);
+    xmlNodePtr node = pcmk__output_create_xml_node(out, "operation_history",
+                                                   "call", crm_element_value(xml_op, XML_LRM_ATTR_CALLID),
+                                                   "task", task,
+                                                   "rc", rc_s,
+                                                   "rc_text", services_ocf_exitcode_str(rc),
+                                                   NULL);
+    free(rc_s);
 
     if (interval_ms_s && !pcmk__str_eq(interval_ms_s, "0", pcmk__str_casei)) {
         char *s = crm_strdup_printf("%sms", interval_ms_s);
@@ -1921,11 +1921,11 @@ pe__ticket_xml(pcmk__output_t *out, va_list args) {
 
     pe_ticket_t *ticket = va_arg(args, pe_ticket_t *);
 
-    node = pcmk__output_create_xml_node(out, "ticket");
-    xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) ticket->id);
-    xmlSetProp(node, (pcmkXmlStr) "status", (pcmkXmlStr) (ticket->granted ? "granted" : "revoked"));
-    xmlSetProp(node, (pcmkXmlStr) "standby",
-               (pcmkXmlStr) pcmk__btoa(ticket->standby));
+    node = pcmk__output_create_xml_node(out, "ticket",
+                                        "id", ticket->id,
+                                        "status", ticket->granted ? "granted" : "revoked",
+                                        "standby", pcmk__btoa(ticket->standby),
+                                        NULL);
 
     if (ticket->last_granted > -1) {
         xmlSetProp(node, (pcmkXmlStr) "last-granted",
diff --git a/tools/crm_resource_print.c b/tools/crm_resource_print.c
index 6303863..ca8bee2 100644
--- a/tools/crm_resource_print.c
+++ b/tools/crm_resource_print.c
@@ -247,9 +247,9 @@ resource_check_xml(pcmk__output_t *out, va_list args) {
     pe_resource_t *parent = uber_parent(checks->rsc);
     int rc = pcmk_rc_no_output;
 
-    xmlNode *node = pcmk__output_create_xml_node(out, "check");
-
-    xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) parent->id);
+    xmlNode *node = pcmk__output_create_xml_node(out, "check",
+                                                 "id", parent->id,
+                                                 NULL);
 
     if (pcmk_is_set(checks->flags, rsc_remain_stopped)) {
         xmlSetProp(node, (pcmkXmlStr) "remain_stopped", (pcmkXmlStr) "true");