diff --git a/docs/developer/repos.md b/docs/developer/repos.md
index 28c4461..13d2225 100644
--- a/docs/developer/repos.md
+++ b/docs/developer/repos.md
@@ -45,7 +45,7 @@
 it will push it in a new branch to the forked repository and create a pull
 request.
 
-> *Note**
+> **Note**
 >
 > If the process fails because of a merge conflict, you'll need to resolve the
 > conflict and then run the command again.
diff --git a/roles/rook_ceph_cluster/README.md b/roles/rook_ceph_cluster/README.md
index c0c87b6..a29cce0 100644
--- a/roles/rook_ceph_cluster/README.md
+++ b/roles/rook_ceph_cluster/README.md
@@ -20,7 +20,7 @@
 * Project Name
 * Domain Name (if you're not sure, this is usually `Default`)
 
-> *Note*
+> **Note**
 >
 > If you're not sure what your authentication URL is, you can find it by logging
 > into your OpenStack dashboard and clicking on *API Access* in the left-hand
@@ -35,7 +35,7 @@
 4. Enter your password
 5. Click *Connect*
 
-> *Note*
+> **Note**
 >
 > While you're connecting, if your cloud is setup with a self-signed
 > certificate, you may see a warning about the certificate being invalid.  You
@@ -44,7 +44,7 @@
 At that point, you should be able to create buckets and upload files by simply
 dragging and dropping them into the Cyberduck window.
 
-> *Note*
+> **Note**
 >
 > Cyberduck is free software with no feature limits.  However, if you find value
 > in it, please consider making a [donation](https://cyberduck.io/donate/)
