diff --git a/concerts/cant2022.json b/concerts/cant2022.json
index 0ce8f50..c01f5fd 100644
--- a/concerts/cant2022.json
+++ b/concerts/cant2022.json
@@ -5,6 +5,8 @@
   "begins": 1648740600,
   "ends": 1648764000,
   "hasTimes": false,
+  "showTitle": false,
+  "customHeader": "<div style='text-align: center; margin: 16px 0;'><img src='img/cartells/cant2022.webp' style='max-width: min(100%, 512px);'></div>",
   "customFooter": "<div style='text-align: right; margin: 16px 0;'><img src='img/logo-biblioteca.png' style='height: 75px;'></div>",
   "songs": [
     {
diff --git a/css/styles.css b/css/styles.css
index 2d517d9..bcf0526 100644
--- a/css/styles.css
+++ b/css/styles.css
@@ -75,6 +75,10 @@
   margin-bottom: 18px;
 }
 
+.booklet-header--invisible {
+  display: none;
+}
+
 .booklet-header .booklet-header-title {
   margin: 0;
   font-size: 30px;
@@ -272,6 +276,14 @@
     border-bottom: solid 1px gray;
   }
 
+  .booklet-header--invisible {
+    display: block;
+  }
+
+  .booklet-custom-header {
+    display: none;
+  }
+
   .song {
     break-inside: avoid-page;
     box-shadow: none;
diff --git a/img/cartells/cant2022.webp b/img/cartells/cant2022.webp
new file mode 100644
index 0000000..3264cf7
--- /dev/null
+++ b/img/cartells/cant2022.webp
Binary files differ
diff --git a/index.html b/index.html
index 38240cd..8960a11 100644
--- a/index.html
+++ b/index.html
@@ -33,7 +33,7 @@
         <div id="previous-concerts-list" class="concerts-list"></div>
       </section>
       <section id="booklet" class="booklet" hidden>
-        <div class="booklet-header">
+        <div id="booklet-header" class="booklet-header">
           <h2 id="concert-title" class="booklet-header-title"></h2>
           <div id="concert-subtitle" class="booklet-header-subtitle"></div>
         </div>
diff --git a/js/script.js b/js/script.js
index aab60d9..927db54 100644
--- a/js/script.js
+++ b/js/script.js
@@ -81,6 +81,12 @@
   document.getElementById('concert-title').textContent = booklet.title;
   document.getElementById('concert-subtitle').textContent = booklet.subtitle;
 
+  if (!booklet?.showTitle)
+    document.getElementById('booklet-header').classList
+        .add('booklet-header--invisible');
+  else
+    document.getElementById('booklet-header').classList
+        .remove('booklet-header--invisible');
   if ('customHeader' in booklet)
     document.getElementById('booklet-custom-header').innerHTML =
         booklet.customHeader;
diff --git a/sw.js b/sw.js
index 51e7c08..36e7e8d 100644
--- a/sw.js
+++ b/sw.js
@@ -1,10 +1,11 @@
-var CACHE_NAME = 'all-v1.1.8';
+var CACHE_NAME = 'all-v1.1.9';
 var urlsToCache = [
   '/',
   '/css/styles.css',
   '/img/logo.svg',
   '/img/logo-biblioteca.png',
   '/img/logo-ciba.png',
+  '/img/cartells/cant2022.webp',
   '/js/script.js',
   '/concerts/nadal2020joves.json',
   '/concerts/nadal2020nens.json',
