
<p class="has-drop-cap">Sju år i rad (!) har Öystein Tjomsland tränat vinnaren i Svenskt Kallblodsderby. De sju vinnarna är med <strong>Philip Ess, Nordsjö Odin, Havglimt, Tangen Bork, Tangen Minto, Bore Mikkel</strong> och ifjol <strong>Frivoll Gorm</strong>. Tjomsland har även segrat med Tekno Odin (e. Moe Odin) 2012 och är med åtta triumfer överlägsen i Derbyhistorien.</p>



<p>Mycket talar för att norrmannen tar en åttonde i rad titel  under lördagen, där tre av stallets hästar kvalade in till final, däribland förhandsfavoriten <strong>Tangen Martin</strong> (e. Bork Odin), som var tvåa i norska Kriteriet ifjol och vann Kungapokalen i våras. <br>– Han har visat väldigt fin utveckling och etablerat sig på hög nivå. Det är en förnuftig och fin häst, sade Tom Erik Solberg efter att ha vunnit på snabbaste försökstiden 1.24,7a/2.140 meter.</p>



<p>Solberg har kört tre av av Tjomslands vinnare i Derbyt, medan tränaren själv suttit bakom fyra. I årets Derby föll valet på <strong>Grude Erling</strong> (e. Nordsjö Odin), som ”bara” slutade femma i försöket efter att ha suttit fastlåst länge.<br>Tredje bidraget är det minst meriterade, <strong>Karmland Lukas</strong> (e. Nordsjö Odin).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/tangenmartin-617x333.jpg" alt="" class="wp-image-749012"/><figcaption class="wp-element-caption">Tangen Martin och Tom Erik Solberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Startlista Kallblodsderbyt</h2>



<p>2.140 meter autostart<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Grisle Best G.L. (e. Nordsjö Odin) – Vidar Tjomsland (Stine Birkeland)</li>



<li>Tangen Martin (e. Bork Odin) – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Hulte Adam (e. Hulte Magnus) – Henrik Kihle (Jan-Olov Persson)</li>



<li>Granbarksborren (e. Bork Odin) – Marcus Lilius (Jan-Olov Persson)</li>



<li>Trollbackens Olov (e. Odin Tabac) – Tomas Pettersson (Lars Holm)</li>



<li>Grude Erling (e. Nordsjö Odin) – Öystein Tjomsland</li>



<li>Bazoo Can (e. Ängsborken) – Isabella Jansson Wiklund (Kai Pakola)</li>



<li>Trollbalder (e. B.W.Modde) – Olli Kouvunen (Jan-Olov Persson)</li>



<li>Nordsjö Prinsen (e. Tekno Odin) – Örjan Kihlström (Öystein Tjomsland)</li>



<li>Gör Som Jag Vill (e. Järvsö Björn) – Ulf Ohlsson (Robert Skoglund)</li>



<li>Karmland Lukas (e. Nordsjö Odin) – Åsbjörn Tengsareid (Öystein Tjomsland)</li>



<li>B.W.Birger (e. Tekno Jerven) – Mats E Djuse (Jan-Olov Persson)</li>
</ol>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/bazoocan3-617x333.jpg" alt="" class="wp-image-752592"/><figcaption class="wp-element-caption">Bazoo Can tillsammans med kusken Isabella Jansson Wiklund och tränaren Kai Pakola. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">En oblyg 19-årig tjej med en tuffing till häst. Lärlingen Isabella Jansson Wiklund och <strong>Bazoo Can</strong> (e. Ängsborken) levererade en präktig skräll i försöken till Svenskt Kallblodsderby när duon spurtade till säkert vinst, hästens fjärde på 18 starter i karriären.<br>– Bazoo Can trivs bäst med att sova i sin hage över natten, så vi kommer att resa på lördag morgon. Senast var första gången han tävlade i en vanlig sulky, tidigare har han gått i långvagn. Vi har funderat på jänkarvagn och barfota fram, men det är långt ifrån säkert. Han är anmäld så, men det där bestämmer vi på lördag, avrundar Isabella Jansson Wiklund.</p>



<p><a href="https://sulkysport.se/vi-aker-inte-for-att-forlora/" target="_blank" rel="noreferrer noopener">Läs hela intervjun med Isabella Jansson Wiklund här!</a></p>



<p>Amatörtränaren Kai Pakola från Kopparberg med licens i Lindesberg är tränaren bakom verket och han har varit med i kallblodiga storloppssammanhang tidigare. <strong>Raska Can</strong> (e. Klack Jo), 1.28,7m*/278.397 kr, var finalist i både Stokriteriet på Bjerke och Derbystoet i Östersund. Största segern kom i finalen i fyraåringsserien Sleipner Cup värd 125.000 kronor två månader före Derbystoet.</p>



<p>Raska Can togs till avel efter fyraåringssäsongen och första avkomman är duktige <strong>Oss Can</strong> (e. Odin Tabac), 1.22,2ak/679.452 kr. Denne kvalade in till Kallblodsderbyt 2020 i Lovisa Canneryds regi.</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/hulteadam-617x333.jpg" alt="" class="wp-image-752948"/><figcaption class="wp-element-caption">Hulte Adam och Henrik Kihle. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Jan-Olov Persson har fyra triumfer i loppets historia. Förutom den svenskfödda trion <strong>Hallsta Lotus</strong> (e. Järvsöfaks), <strong>Järvsöviking</strong> (e. Järvsöfaks) och <strong>Järvsö Pegasus</strong> (e. Tangen Scott) tränade han även norskfödde <strong>Stjerne Faks</strong> (e. Järvsöfaks), som vann 2007.</p>



<p>Nu har det gått åtta år sedan en Persson-häst senast tog hem svenska Derbyt, Järvsö Pegasus 2017, och Hagmyrentränaren rustar med en kvartett i årets final.</p>



<p><strong>Hulte Adam</strong> (e. Hulte Magnus) var längst fram i försöken när han slutade tvåa bakom Tangen Martin, medan <strong>Granbarksborren</strong> (e. Bork Odin) reparerade galopp till tredjeplatsen i försöket som vanns av Bazoo Can. Perssons övriga bidrag är <strong>Trollbalder</strong> (e. B.W.Modde) och <strong>B.W.Birger</strong> (e. Tekno Jerven).</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">1986 släpptes de norskfödda travarna in i den svenska klassikern för första gången och sedan premiären är det stor övervikt Norge bland de 39 vinnare som korats: 30–9!</p>



<p>I årets startfält är det liten övervikt Sverige på förhand, då sju av tolv finalister i Derbyt är födda här. De två uttagningsloppen fördelades jämnt genom norske <strong>Tangen Martin</strong> (e. Bork Odin) och svenske <strong>Bazoo Can</strong> (e. Ängsborken).</p>



<p><strong>De svenskfödda vinnarna sedan 1986:</strong></p>



<ul class="wp-block-list">
<li>1986 <strong>Lundick</strong> (e. Pavjol) – Alf Jonsson</li>



<li>1990 <strong>Erk Tron</strong> (e. Slogum Tron) – Åke Sundberg (Sven Abenius)</li>



<li>1993 <strong>Pålex K.</strong> (e. Pål Best) – Lars I Eriksson</li>



<li>1998 <strong>Rolex K.</strong> (e. Troll Jahn) – Lars I Eriksson</li>



<li>2003 <strong>Troll Kevin</strong> (e. Troll Jahn) – Jan Norberg</li>



<li>2004 <strong>Hallsta Lotus</strong> (e. Järvsöfaks) – Jan-Olov Persson</li>



<li>2008 <strong>Järvsöviking</strong> (e. Järvsöfaks) – Jan-Olov Persson</li>



<li>2011 <strong>Månprinsen A.M.</strong> (e. Svall Ivar) – Gunnar Melander</li>



<li>2017 <strong>Järvsö Pegasus</strong> (e. Tangen Scott) – Örjan Kihlström (Jan-Olov Persson)</li>
</ul>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/gorsomjagvillrs-617x333.jpg" alt="" class="wp-image-750766"/><figcaption class="wp-element-caption">2024 års Kriterievinnare Gör Som Jag Vill och Robert Skoglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Bara fem hästar har lyckats med att ta dubbeln Svenskt Kallblodskriterium och Svenskt Kallblodsderby sedan Kriteriet gjorde entré 1993.<br>Robert Skoglund är mannen bakom <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn), som slog till på Dannero förra året, och nu kan fylla på med en andra svensk klassiker. Gör Som jag Vill slutade även trea i norska Kriteroet förra året under en säsong som inbringade nästan 800.000 kronor.</p>



<p>Hästens mamma <strong>Lax Vilja</strong> (e. Moe Odin), 1.31,4ak/91.100 kr, gjorde inga stora avtryck på tävlingsbanan med en seger på 27 starter, men fick sin revansch i avelsboxen. Tolv avkommor fick Elitstoet innan hon gick bort och elva av dem är i startbar ålder. Samtliga har startat och alla utom en har dessutom vunnit lopp.</p>



<p>Pärlan i sammanhanget är – hittills är bäst att tillägga – stoet <strong>Uggla I Mossen</strong> (e. Järvsöfaks), 1.24,2m/1.932.686 kr, som var 2013-kullens drottning med dubbla Kriteriestosegrar och vinst i Biris Uppfödningslopp som treåring, samt seger i Stoderbyt i Norge som fyraåring i Jan-Olov Perssons regi.<br>Ytterligare tre miljonärer finns hittills i syskonskaran: <strong>Envis</strong> (e. Lome Brage), 1.21,8am*/1.389.281 kr, <strong>Buska Blyg</strong> (e. Järvsöviking), 1.22,4ak/1.208.700 kr, och <strong>Crussi Dull</strong> (e. Hellin Faxen), 1.23,5ak*/1.003.393 kr. Dessutom slutade Gör Som Jag Vills lillebror <strong>Hu Så Hemskt</strong> (e. Järvsö Björn) femma i Kriteriet förra veckan.</p>



<p><strong>Hästarna som tagit den klassiska dubbeln i Sverige:</strong></p>



<ul class="wp-block-list">
<li>1997-1998 <strong>Rolex K.</strong> (e. Troll Jahn) – Lars I Eriksson</li>



<li>2002-2003 <strong>Troll Kevin</strong> (e. Troll Jahn) – Jan Norberg</li>



<li>2004-2005 <strong>H.G.Balder</strong> (e. Lome Elden) – Vidar Hop (John Hasle)</li>



<li>2005-2006 <strong>Slått Eld</strong> (e. Lome Elden) – Jomar Blekkan</li>



<li>2013-2014 <strong>Lannem Silje</strong> (e. Åsajerven) – Tor Wollebaek (Ola M Skrugstad)</li>
</ul>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/jrvsfaksihagen-617x288.jpg" alt="Sulkysport, Travsport, Trav, Häst, Järvsöfaks" class="wp-image-17802"/><figcaption class="wp-element-caption">Järvsöfaks. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Järvsöfaks fick ge sig mot Rolex K. när han själv startade i Svenskt Kallblodsderby 1998, men han blev ju en vinnare på alla sätt efter den andraplatsen. Som i Derbysammanhang, där han är pappa till sex vinnare i historien. Tillsammans med Solo är den svenske stjärnan störst.</p>



<p>Järvsöfaks sista avkommor föddes 2015 och hans blod lever i högst grad vidare. I årets Derbyfält bär fem av tolv hästar hans blod.</p>



<p>Han är morfars far till <strong>Trollbackens Olov</strong>, farmors far till <strong>Trollbalder</strong> och <strong>Gör Som Jag Vill</strong>, farmors farfar till <strong>Bazoo Can</strong>, samt både farmors farfar och mormors morfar till <strong>B.W.Birger</strong>.</p>



<p><strong>Flest Derbysegrar som far:</strong></p>



<ul class="wp-block-list">
<li>Sex segrar: Järvsöfaks, Solo</li>



<li>Fem segrar: Pavin, Steggbest</li>



<li>Fyra segrar: Moe Odin, Remin</li>



<li>Tre segrar: Alm Rigel, Elding, Skarphedin, Troll Jahn</li>
</ul>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/bazoocan2-617x333.jpg" alt="" class="wp-image-749022"/><figcaption class="wp-element-caption"> Bazoo Can och Isabella Jansson Wiklund spurtar hem sitt försök till Svenskt Kallblodsderby. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Förra året hade svenskfödde Ängsborken sina första fyraåringar på tävlingsbanan och det blev succé genom sonen <strong>Frivoll Gorm</strong>, som vann Derbyt i både Sverige och Norge, och dottern <strong>Voje Lotta</strong> som vann Stoderbyt i Norge.</p>



<p>Med sin andra kull ställer Ängsborken hoppet till försöksvinnaren <strong>Bazoo Can. </strong></p>



<p>Ytterligare två av avelshingstarna bakom årets finalister har lämnat vinnare tidigare. Bork Odin, som är far till <strong>Tangen Martin</strong> och <strong>Granbarksborren</strong>, var pappa till vinnaren två år i rad. 2021 vann <strong>Tangen Bork</strong> och 2022 segrade <strong>Tangen Minto</strong>.</p>



<p><strong>Tekno Odin</strong>, som själv vann Derbyt 2012, har en vinnare på sitt cv i 2019 års etta <strong>Nordsjö Odin</strong>. I år ställer Sveriges championhingst de senaste åren hoppet till <strong>Nordsjö Prinsen</strong>, lillebror till Nordsjö Odin. </p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">N<strong>ordsjö Odin</strong> (e. Tekno Odin) är tidernas snabbaste vinnare av Svenskt Kallblodsderby. För sex år sedan stormade han fram på 1.22,0a/2.140 meter tillsammans med sin tränare Öystein Tjomsland.</p>



<p>I år har han sin första kull fyraåringar på tävlingsbanan och till Derbyt kvalade tre söner in – flest av alla avelshingstar. <strong>Grisle Best G.L, Grude Erling </strong>och <strong>Karmland Lukas</strong> är hästarna som ska hålla pappans fana högst.</p>



<p><strong>De snabbaste vinnarna i Svenskt Kallblodsderby:</strong></p>



<ul class="wp-block-list">
<li>1.22,0 – <strong>Nordsjö Odin</strong> (e. Tekno Odin – Nordli Vinni), 2019, Öystein Tjomsland</li>



<li>1.22,6 – <strong>Tangen Bork</strong> (e. Bork Odin – Tangen Stöva), 2021, Tom Erik Solberg</li>



<li>1.22,9 – <strong>Tekno Odin</strong> (e. Moe Odin – Lyana), 2012, Öystein Tjomsland</li>



<li>1.23,1 – <strong>Lannem Silje</strong> (e. Åsajerven – Lannem Sjura), 2014, Tor Wollebaek</li>



<li>1.23,1 – <strong>Bore Mikkel</strong> (e. Moe Odin – Ridder Rosa), 2023, Öystein Tjomsland</li>



<li>1.23,5 – <strong>Tangen Minto</strong> (e. Bork Odin – Mangen Mina), 2022, Tom Erik Solberg</li>



<li>1.24,0 – <strong>Philip Ess</strong> (e. Briskeby Philip – Tangen Pia), 2019, Öystein Tjomsland</li>



<li>1.24,0 – <strong>Havglimt</strong> (e. Moe Odin – Sjefslill), 1.24,0, 2020, Öystein Tjomsland</li>
</ul>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/trollbackensolov-617x333.jpg" alt="" class="wp-image-752949"/><figcaption class="wp-element-caption">Lars Holm-tränade Trollbackens Olov och Tomas Pettersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Bergsåkeramatören Lars Holms <strong>Trollbackens Olov</strong> (e. Odin Tabac) hade en finfin treåringssäsong med nästan trekvarts miljon kronor insprunget och andraplatsen i Svenskt Kallblodskriterium som kronan på verket. Dessutom plockade han hem tre lopp med 100.000 kronor i förstapris som treåring: Hälsinglands Treåringspris, Svensk Travsports Treåringsstjärna och finalen i Norrlands Elitserie.</p>



<p>I år har han följt upp med två segrar och fjärdeplatsen i försöket. </p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Kallbloden har aldrig spelat någon stor roll hos Menhammar Stuteri, men i mars 1948 förvärvade Olof Wallenius två nordsvenska travare. <strong>Mollvi</strong> var den ena och Olof Wallenius lät betäcka henne med Solo, vilket utmynnade i <strong>Jäntungen</strong>, 1.34,3/90.080 kronor.</p>



<p>Jäntungen såldes som fyraåring. Hon tävlade för Oscar Söderlund i Bergsjö. Stoet var svår att få dräktig och Jäntungen köptes senare av Ingemar Persson, bror till Järvsöfaks tränare Jan-Olov.<br>Ingemar Persson gav inte slaget förlorat och vid 18 års ålder blev Jäntungen dräktig. Hennes första avkomma <strong>Skarpjänta</strong> föddes 1968. Tre år senare såg Järvsöfaks mormors mor <strong>Steggjänta</strong> (e. Steggbest), 1.34,3k*/27 600 kr, dagens ljus.</p>



<p>Bakom Steggjänta tog för övrigt Jan-Olov Persson sin första seger i sulkyn – Östersund 1977.</p>



<p>I Svenskt Kallblodsderby i år är Menhammar Stuteri uppfödare till två av finalisterna, men när det gäller <strong>Granbarksborren</strong> (e. Bork Odin) saknas faktiskt både Järvsöfaks och Jäntungen i stamtavlan.<br>I blodet bakom <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) finns Järvsöfaks, som farfars far via sonen Järvsöviking och sonsonen Järvsö Björn.</p>



<h2 class="wp-block-heading">Hästägare &#038; uppfödare Kallblodsderbyt</h2>



<p><em>Häst – Ägare – Uppfödare</em></p>



<ol class="wp-block-list">
<li><strong>Grisle Best G.L. </strong>– Team Vinnarskalle, Norge – Gustav Larsen, Norge</li>



<li><strong>Tangen Martin</strong> – N.Munkhaugen Holding AS, Norge – Jörn Gunnar Nilsen, Norge</li>



<li><strong>Hulte Adam</strong> – Stall Zetterbjörks/Easy – Stall Hulte KB, Bergsjö</li>



<li><strong>Granbarksborren</strong> – Travkompaniets Stall AB, Ekerö – Menhammar Stuteri AB, Ekerö</li>



<li><strong>Trollbackens Olov</strong> – Lars Holm &#038; Emilie Öberg – Emelie Nordin &#038; Richard Sörensson</li>



<li><strong>Grude Erling</strong> – Martin Hove, Norge – Martin Hove, Norge</li>



<li><strong>Bazoo Can</strong> – Kai Pakola, Kopparberg – Kai Pakola &#038; Helena Canneryd</li>



<li><strong>Trollbalder</strong> – Ofcourse KB, Kovland – Stall Kiro AB, Skellefteå</li>



<li><strong>Nordsjö Prinsen</strong> – Ofcourse KB, Kovland – Rune Erga &#038; Johannes Wiig</li>



<li><strong>Gör Som Jag Vill</strong> – Robert Skoglund, med flera – Menhammar Stuteri AB, Ekerö</li>



<li><strong>Karmland Lukas</strong> – Bergsåker Open Trotters KB – John I Naustvik, Norge</li>



<li><strong>B.W.Birger</strong> – Tekno Odin AB (Jan-Olov Persson) – Birger Wallström, Älvsjö</li>
</ol>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/5tangenbork2-617x333.jpg" alt="" class="wp-image-723123"/><figcaption class="wp-element-caption">Celine Fåland Hansen tillsammans med Tangen Bork, kusken Tom Erik Solberg och tränaren Öystein Tjomsland efter segern i Elitkampen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Att ha en häst med i klassisk final är en dröm för många hästskötare. Maja Klar och Jenny Pettersson har till och med två sammanlagt i Derbyt och Derbystoet. Fast Jan-Olov Persson-duon står sig ändå slätt mot en norska.</p>



<p>Celine Fåland Hansen, anställd hos Öystein Tjomsland, har hela fyra finalister!</p>



<p>Fast Celine är van hetluften och stora sammanhang. På Elitloppsdagen i år till exempel tog hon emot publikens hyllningar sedan Tangen Bork vunnit Elitkampen.</p>



<p><strong>Hästskötare Kallblodsderbyt</strong></p>



<ul class="wp-block-list">
<li>Stine Birkeland – Grisle Best G.L. </li>



<li>Guro Mogset – Tangen Martin</li>



<li>Chloe Pettersson – Hulte Adam</li>



<li>Engla Sund – Granbarksborren</li>



<li>Emilie Öberg – Trollbackens Olov</li>



<li>Celine Fåland Hansen – Grude Erling</li>



<li>Kai Pakola – Bazoo Can</li>



<li>Maja Klar – Trollbalder</li>



<li>Anna-Karin Jonsson – Nordsjö Prinsen</li>



<li>Johanna Frunck – Gör Som Jag Vill</li>



<li>Celine Fåland Hansen – Karmland Lukas</li>



<li>Maja Klar – B.W.Birger</li>
</ul>



<p><strong>Hästskötare Derbystoet</strong></p>



<ul class="wp-block-list">
<li>Anders Wallin – Björgen</li>



<li>Camilla Röste – Hög Decibel</li>



<li>Vilde Abusdal – Hå Lerke</li>



<li>Ellen Marie Folkvord – Brenne Viktoria</li>



<li>Camilla Hjärpe – Guli Sanna</li>



<li>Celine Fåland Hansen – Stavre Maggan</li>



<li>Sanna Gustavsson – Mynta V.S.</li>



<li>Tor A Eggen – R.M.G.Sommerfugl</li>



<li>Jenny Pettersson – Hertiginnan Stöen</li>



<li>Jenny Pettersson – Eld Prinsessa </li>



<li>Celine Fåland Hansen – Salte Rappa </li>



<li>Ranja Bjurman – M.P.Flora </li>
</ul>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="kAXaxGaX1f"><a href="https://sulkysport.se/derbystoet-nobbade-hingstens-revansch/">Derbystoet: Nobbad tar revansch?</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Derbystoet: Nobbad tar revansch?” &ndash; Sulkysport" src="https://sulkysport.se/derbystoet-nobbade-hingstens-revansch/embed/#?secret=ozIorZaebf#?secret=kAXaxGaX1f" data-secret="kAXaxGaX1f" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
