diff --git a/examples/quarkus/pom.xml b/examples/quarkus/pom.xml
index 25e4f8b..70c923e 100644
--- a/examples/quarkus/pom.xml
+++ b/examples/quarkus/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>eu.mulk.quarkus-googlecloud-jsonlogging</groupId>
     <artifactId>quarkus-googlecloud-jsonlogging-parent</artifactId>
-    <version>6.0.0</version>
+    <version>6.1.0</version>
   </parent>
 
   <artifactId>quarkus-googlecloud-jsonlogging-quarkus-example</artifactId>
diff --git a/examples/spring-boot/pom.xml b/examples/spring-boot/pom.xml
index 8cb994a..4f893b7 100644
--- a/examples/spring-boot/pom.xml
+++ b/examples/spring-boot/pom.xml
@@ -16,7 +16,7 @@
   <parent>
     <groupId>eu.mulk.quarkus-googlecloud-jsonlogging</groupId>
     <artifactId>quarkus-googlecloud-jsonlogging-parent</artifactId>
-    <version>6.0.0</version>
+    <version>6.1.0</version>
   </parent>
 
   <artifactId>quarkus-googlecloud-jsonlogging-spring-boot-example</artifactId>
diff --git a/examples/spring-boot/src/main/resources/logging.properties b/examples/spring-boot/src/main/resources/logging.properties
index 8bc0033..ba75dff 100644
--- a/examples/spring-boot/src/main/resources/logging.properties
+++ b/examples/spring-boot/src/main/resources/logging.properties
@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-# java.util.logging properties
+# java.util.logging properties (not used)
 #handlers = eu.mulk.quarkus.googlecloud.jsonlogging.logmanager.DefaultConsoleHandler
 #.level = INFO
 
