
<p class="has-drop-cap">Med två av fem försöksvinnare kan Mattias Djuse spela huvudrollen i långa E3-finalen för ston. Mattias har firat framgångar med unghästar tidigare och i E3-sammanhang på stosidan har han haft hela 24 hästar i finalerna – med fint facit.<br>För tre år sedan hade Mattias fyra av tio finalister i korta upplagan och det slutade med dubbelseger när <strong>A Teaser</strong> (e. Flocki d’Aurcy) vann före <strong>Larah Westwood</strong> (e. The Bank). Mattias har även räknat in andraplatser i finaler för <strong>Global Allegiance</strong> (e. S.J.’s Caviar), <strong>M.T.Perette</strong> (e. The Bank) och <strong>Olivia Bros</strong> (e. Muscle Mass)</p>



<p>Nu handlar det om långa upplagan och första gången blev det ”bara” en sjätteplats, men utdelningen skulle komma. Det handlade nämligen om Mattias toppsto <strong>Racing Brodda</strong> (e. Prodigious), 1.10,5ak/7.831.250 kr, som senare under karriären vann Derbystoet och slutade tvåa i Stochampionatet.<br>Mattias väntar fortfarande på seger i långa E3, men kan luta sig mot en andraplats för <strong>Knickers Sisu</strong> (e. Southwind Frank) 2023.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/mattiasdjuse-617x333.jpg" alt="" class="wp-image-656381"/><figcaption class="wp-element-caption">Mattias Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Solvallatränarens två hopp på lördagen vann alltså båda sina försök från ledningen.<br><strong>Najade Quesnoy</strong> (e. Enino du Pommereux) vann försök tillsammans med Magnus A Djuse och körs nu av Mats E Djuse.<br>– Hon gjorde det väldigt bra i försöket. Hon hade tränat bra hela vintern och var fin i debuten, som hon vann, men sedan var hon halvseg i några starter och löpte inte upp till det vi hoppades på, men vi har ju laddat mot E3. Hon har inte jättemånga lopp att gå i här i Sverige, så det är klart att E3 var ett mål för hennes del, säger Mattias Djuse.</p>



<p>Magnus val av häst i finalen är <strong>Fusion Blaze</strong> (e. Southwind Frank).<br>– Med henne kände jag tidigt att hon är något extra och hon har gjort det jättebra i alla starter. Det är ju en grej att känna det man känner i jobben till att hästarna ska leverera på banan, det har man lärt sig genom åren, men i hennes fall har hon inte gjort mig besviken. I försöket fick hon bestämma i ledningen utan att behöva bli trött, säger Mattias Djuse.</p>



<p><a href="https://sulkysport.se/djuses-fransyska-mot-djuses-svenska/" target="_blank" rel="noreferrer noopener">––> Läs hela intervjun med Mattias Djuse inför E3-finalen här!</a></p>



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



<p>2.140 meter autostart, Bergsåker lördag<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Briljant Töll</strong> (e. Day or Night In) – Viktor Lyck</li>



<li><strong>Mezzanine</strong> (e. Gimpanzee) – Roger Walmann</li>



<li><strong>Najade Quesnoy</strong> (e. Enino du Pommereux) – Mattias Djuse</li>



<li><strong>Fusion Blaze</strong> (e. Southwind Frank) – Mattias Djuse</li>



<li><strong>Västerbo Sparkly</strong> (e. Django Riff) – Paul Hagoort</li>



<li><strong>Thai Medina</strong> (e. Face Time Bourbon) – Björn Goop</li>



<li><strong>Rosie Bros</strong> (e. Maharajah) – Dion Tesselaar</li>



<li><strong>Aperfectsavior</strong> (e. Readly Express) – Joakim Elfving</li>



<li><strong>Ismenis</strong> (e. Calgary Games) – Jasmine Ising</li>



<li><strong>Morning Rain</strong> (e. Face Time Bourbon) – Daniel Wäjersten</li>



<li><strong>Calgary Flames</strong> (e. Calgary Games) – Daniel Wäjersten</li>



<li><strong>Diamond In Pj’s</strong> (e. Father Patrick) – Fredrik Wallin</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/2026/06/mezzaninernsgktz-617x333.jpg" alt="" class="wp-image-862586"/><figcaption class="wp-element-caption">Roger Walmann-tränade Mezzanine och Rikard N Skoglund lekte hem sitt försök till E3 i Örebro. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Roger Walmann toppar tränarligan i E3:s stoklass med sju vinnare sedan storloppet såg dagens ljus 1997. <strong>Tamla Celeber</strong> (e. Cantab Hall) och <strong>Giant Diablo</strong> (e. Supergill) vann dubbla finaler, medan <strong>Mellby Briolett</strong> (e. Going Kronos), <strong>Nursery Rhyme</strong> (e. Credit Winner) och <strong>S.G.Empress</strong> (e. Readly Express) vann en upplaga vardera.</p>



<p>Tränarnestorn är med även i årets final, och har ett spännande kort i <strong>Mezzanine</strong> (e. Gimpanzee) som bland annat har en vass storebror att leva upp till. Mamma <strong>Deepdish</strong> (e. Muscle Hill), som köptes av Lennart Ågren i Lexington som ettåring för 320.000 dollar, har sin första avkomma i Kriterievinnaren <strong>Brambling</strong> (e. Bold Eagle), 1.09,7ak/5.760.091 kr.</p>



<p>Mezzanine glänste i sitt uttagningslopp, där Rikard N Skoglund tidigt valde positionen utvändigt ledaren och därifrån gled Mezzanine undan på fint sätt och var långt ifrån bottnad.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/briljanttollrnsgk-617x333.jpg" alt="" class="wp-image-867468"/><figcaption class="wp-element-caption">Viktor Lyck-tränade Briljant Töll och Rikard N Skoglund vid vinst i E3-kvalet. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Två tidigare lärjungar hos Svante Båth stor för en fjärdedel av finalisterna i stoklassen. Rättviktränaren Viktor Lyck kvalade in <strong>Interwall</strong> (e. Interwall) till långa E3 för fyra år sedan, men gick lottlös från finalen.</p>



<p>Nu har Viktor en ny finalist i försöksvinnaren <strong>Briljant Töll</strong> (e. Day Or Night In), som också är finalfältets mest rutinerade häst med tolv starter (3-0-4) innanför västen. </p>



<p>Daniel Wäjersten fick något av sitt genombrott som tränare när han vann långa E3 för hingstar/valacker med <strong>Global Badman</strong> (e. Yield Boko) hemma på Bergsåker 2020. I år har han <strong>Mister Nabab</strong> (e. Mister J.P.) i hingstklassen och dubbla hopp på stosidan.<br>Både <strong>Morning Rain</strong> (e. Face Time Bourbon) och <strong>Calgary Flames</strong> (e. Calgary Games) slutade tvåa i sina försök och inleder från bakspår.<br>– Det är två fina hästar som börjat bra, men som kanske inte har snabbheten än för att dyka upp långt framme, sade Daniel Wäjersten till V65 Direkt.</p>



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



<p class="has-drop-cap">Maharajah var kungen av E3-finalen på Bergsåker 2008 när hans insats till och med gjorde körande Örjan Kihlström tårögd. I livet efter tävlingsbanan har Maharajah radat upp finalister i E3-finalerna och bland hingstarna och valackerna segrade sonen <strong>Dream Mine</strong> i långa finalen för två år sedan.<br>På stosidan väntar Maharajah – efter 28 försök – faktiskt fortfarande på första segern. Hästen som kan bryta den sviten i år Dion Tesselaar-tränade <strong>Rosie Bros</strong> (e. Maharajah), som följde upp tredjeplatsen i Breeders Course-finalen på Elitloppsdagen med att sluta tvåa i sitt E3-kval bakom <strong>Najade Quesnoy</strong>.</p>



<p>Calgary Games har sina första treåringar på banan 2026 och två av hans döttrar kvalade in till final: <strong>Ismenis</strong> och <strong>Calgary Flames</strong>.</p>



<p>Två finalister är även Face Time Bourbon pappa till genom <strong>Thai Medina</strong> och <strong>Morning Rain</strong>. Face Time Bourbon har en vinnare tidigare i <strong>Screen Time Limit</strong>, då tränad av Reijo Liljendahl.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/vasterbosparklyrbm260615o-617x383.jpg" alt="" class="wp-image-867469"/><figcaption class="wp-element-caption">Västerbo Sparkly blir pappa Django Riffs andra finalist i E3. Foto Gunilla König/Stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Avelshingstarna i E3 för ston</h2>



<p><em>Avelshingst (finalister 2026) – Antal tidigare finalister</em></p>



<ul class="wp-block-list">
<li><strong>Django Riff</strong> (1) – Good Vibes* (2) 2021</li>



<li><strong>Face Time Bourbon</strong> (2) – 7 – Karma Mearas* (6) 2023, Elisabeth Bar* (0) 2023, Esperia Font* (0) 2023, Kitty Mearas* (0) 2023, Käraste Sisu* (0) 2023, <strong>Screen the Limit</strong>* (1) 2024, Lilium Sisu* (6) 2024</li>



<li><strong>Father Patrick</strong> (1) – 6 – Award Kronos* (0) 2019, Philomenia** (0) 2020,  Joli Mearas* (3) 2022, Loveletter In** (6) 2023, Oriana Boko* (3) 2024, Oriana Boko** (3) 2024.</li>



<li><strong>Maharajah</strong> (1) – 28 – Unstirred Drink* (3) 2016, Unstirred Drink** (6) 2016, Under the Counter* (0) 2016, White Lightning** (2) 2017, White Lightning* (3) 2017, Elektra** (0) 2017, Aleppo Pine** (3) 2018, Aleppo Pine* (0) 2018, I’m Sailing* (0) 2018, Base Line** (6) 2019, Malvha Ha* (2) 2020, Malvha Ha** (5) 2020, Nikita Sunrise** (6) 2020, Jes Angel** (0) 2020, Namanga Bo** (str) 2020, Florence Ima** (6) 2021, Amoa Queen** (0) 2021, One Night Only* (0) 2021, Eireann* (2) 2022, O’Mara Zon** (2) 2022, Kayla Westwood* (3) 2022, Caradja** (3) 2022, Lilian Young* (5) 2022, Caradja* (0) 2022, Esmeralda Bez* (0) 2023, Esmeralda Bez** (0) 2023, Sassy But Classy* (4) 2025, Västerbo Carretera* (0) 2025</li>



<li><strong>Readly Express</strong> (1) – 10 – Honey Mearas* (6) 2020, <strong>Red Lady Express</strong>* (1) 2021, Bright Crystal* (5) 2021, Lacille Boko* (0) 2021, Lacille Boko** (0) 2021, <strong>S.G. Empress</strong>** (1) 2024, S.G. Empress* (0) 2024, Kobra Brick* (1) 2025, Pure Stella* (5) 2025, Pure Stella** (5) 2025</li>



<li><strong>Southwind Frank</strong> (1) – 5 – Impala Am* (0) 2021, Impala Am** (5) 2021, Lollo Trot** (0) 2022, Knickers Sisu* (2) 2023, Knickers Sisu** (4) 2023.</li>
</ul>



<p><strong>Calgary Games</strong> (2) har sin första kull ute på travbanan i år. <strong>Day Or Night In</strong> (1), <strong>Enino du Pommereux</strong> (1) och <strong>Gimpanzee</strong> (1) har också sin första avkomma till start.</p>



<p><strong>Fotnot:</strong> Deltog i *långa E3, **korta E3.</p>



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



<p class="has-drop-cap">Super Arnie är unik bland morfäderna som har ättlingar till start i stofinalen. Han är nämligen den ende som lyckats vinna som morfar i långa E3:s historia. Hästen som ordnade vinsten var Robert Bergh-tränade <strong>Timbal</strong> (e. From Above), 1.12,4am*/2.676.479 kr, som vann för elva år sedan.</p>



<p>Elva morfädrar finns representerade i årets final, där Donato Hanover är ensam om dubbla hopp i <strong>Morning Rain</strong> (e. Face Time Bourbon) och <strong>Diamond In Pj’s</strong> (e. Father Patrick).</p>



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



<p class="has-drop-cap">När det gäller utlandsfödda vinnare av långa varianten av E3, så har segern gått till hästar födda utanför Sveriges gränser fyra gånger tidigare på 28 finaler. Tre segrar till Finland och en till Italien.</p>



<p>I årets final kan det för första gången bli en franskfödd vinnare i Mattias Djuse-tränade <strong>Najade Quesnoy</strong> (e. Enino du Pommereux).</p>



<p><strong>Utlandsfödda vinnare i långa E3 för ston:</strong><br><em>År, vinnare (far) – Födelseland</em></p>



<ul class="wp-block-list">
<li>1999 <strong>Monkey Ride</strong> (e. Express Ride) – Finland</li>



<li>2014 <strong>Arctic Model</strong> (e. Classic Photo) – Finland</li>



<li>2017 <strong>Violet Bi</strong> (e. Equinox Bi) – Italien</li>



<li>2019 <strong>Mascate Match</strong> (e. Muscle Mass) – Finland</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/2022/08/sparvenmfadam-617x333.jpeg" alt="" class="wp-image-336727"/><figcaption class="wp-element-caption">Jörgen Westholm tränade E3-vinnaren Sparven. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Lilla speedkulan <strong>Sparven</strong> (e. Bird Barker), 1.12,2am/2.425.000 kr, vann ett enda lopp i karriären, men hon valde rätt tillfälle. Som tidernas största skräll i E3-sammanhang slog hon nämligen till i stonas långa final 2022 tillsammans med Mika Forss och plockade hem segerpremien på två miljoner kronor som 124-oddsare.</p>



<p>Sparven var uppfödd av Lena Martell på Gotland tillsammans med AB Svensk Reklamfinans och båda uppfödarna finns med i årets stofinal – men med varsin häst den här gången.<br>Lena Martell är tillsammans med Stall ZENO AB uppfödare till <strong>Aperfectsavior</strong> (e. Readly Express), medan AB Svensk Reklamfinans står bakom <strong>Mezzanine</strong> (e. Gimpanzee).</p>



<p><strong>Uppfödarna bakom E3-finalisterna:</strong></p>



<ol class="wp-block-list">
<li>Briljant Töll – Inge Carlsson &#038; Robert Lindström</li>



<li>Mezzanine – AB Svensk Reklamfinans, Halmstad</li>



<li>Najade Quesnoy – Willem Verbeke, Belgien</li>



<li>Fusion Blaze – Global Farm AB, Nacka</li>



<li>Västerbo Sparkly – Västerbo Stuteri AB, Heby</li>



<li>Thai Medina – Thaihester Egersund A/S, Danmark</li>



<li>Rosie Bros – Bros Stables, Nederländerna</li>



<li>Aperfectsavior – Martell Lena &#038; Stall ZENO AB</li>



<li>Ismenis – Menhammar Stuteri AB, Ekerö</li>



<li>Morning Rain – Thomas Lind-Holm, Danmark</li>



<li>Calgary Flames – Jan Johansson &#038; Linda Forsberg</li>



<li>Diamond In Pj’s – Hyllstofta Stuteri AB &#038; J Lundgren</li>
</ol>



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



<p class="has-drop-cap">För 400.000 kronor bytte <strong>Diamond In Pj&#8217;s</strong> (e. Father Patrick) ägare på en extrainsatt Traveraauktion. Köpare var Patrik Olsson, Uddevalla, som bland annat äger och numera tränar miljonärskan <strong>Kaffeåchampagne</strong> (e. Butler).</p>



<p>Av finalisterna var franskfödda <strong>Najade Quesnoy</strong> (e. Enino du Pommeraux) dyrast i auktionsringen. Mattias Djuse ropade in henne för 32.000 euro i Deauville.<br>Nästan lika mycket, fast i svensk valuta, betalade B.S.Stables AB; Vimmerby, när <strong>Thai Medina</strong> (e. Face Time Bourbon) ropades in för 300.000 kronor på Solvalla Yearling Sale.</p>



<p><strong>Auktionspriser som ettåringar:</strong></p>



<ul class="wp-block-list">
<li>Najade Quesnoy – Deauville – €32.000</li>



<li>Thai Medina – Solvalla Yearling Sale – 300.000 kr</li>



<li>Ismenis – Menhammar Online – 110.000 kr</li>



<li>Västerbo Sparkly – Next Generation Sale – 80.000 kr</li>



<li>Diamond In Pj’s – Åby Yearling Sale – 50.000 kr</li>
</ul>



<p><strong>Fotnot: </strong>Rosie Bros ropades åter för 110.000 kronor på Elitauktionen. Aperfectsavoir ropades åter för 80.000 kronor på Elitauktionen. </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/09/ismenispfgktz-617x333.jpg" alt="" class="wp-image-772492"/><figcaption class="wp-element-caption">Jasmin Ising-tränade Ismenis och Patrik Fernlund vid seger i debuten som tvååring. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Rommetränaren Jasmine Ising är med i långa E3-finalen för andra gången. 2023 kvalade <strong>Kitty Mearas</strong> (e. Face Time Bourbon) in, men hamnade precis utanför prispengarna i finalen som sjua.</p>



<p><strong>Ismenis</strong> (e. Calgary Games) heter hennes bidrag i år. Hästen fick känna på tävling som tvååring med gott resultat. Tre starter gav två segrar och ett andrapris. 2026 väntar hon fortfarande på första årssegern.<br>Kanske kan Ismenis ge mamma <strong>Undine</strong> (e. Zola Boko), 1.11,9ak/2.000.240 kr, en riktig E3-revansch. Undine slutade nämligen tvåa i långa E3-finalen för tio år sedan.</p>



<p>Av finalisterna tävlade även <strong>Briljant Töll</strong> (e. Day or Night In), <strong>Rosie Bros</strong> (e. Maharajah) och <strong>Diamond In Pj’s</strong> (e. Father Patrick) som tvååringar med framgång. Bäst lyckades Fredrik Wallins Diamond In Pj’s med 421.602 kronor insprunget och andraplatsen i Breeders Course-finalen som tyngsta merit.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/thaimedinabgadam-617x333.jpg" alt="" class="wp-image-867471"/><figcaption class="wp-element-caption">Thai Medina och Björn Goop. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Medan fyra finalister tävlade redan som tvååring så debuterade två av komkurrenterna så sent som i maj som treåringar. Det gäller Daniel Wäjerstens <strong>Morning Rain</strong> och Björn Goops <strong>Thai Medina</strong>, båda med Face Time Bourbon som pappa. Duon har också bara hunnit med tre starter, minst i fältet. </p>



<p>Thai Medina debuterade med vinst den 7 maj med tränare Goop i vagnen och hon är lillasyster till bland annat Geir Vegard Gundersens segermaskin <strong>Bold Eagle Sun</strong> (e. Bold Eagle), som inledde tävlingskarriären med tio raka segrar! Nu har han dock gått på pumpen två gånger i rad.</p>



<p>Modern <strong>Gematria</strong> (e. Explosive Matter), 1.11,2ak/1.976.761 NOK, tävlade själv framgångsrikt på båda sidor om Atlanten med 17 segrar totalt.</p>



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



<p class="has-drop-cap">Mattias Djuse sticker ut bland hästägarna bakom de tolv finalisterna. Han är nämligen den ende tränaren som äger sin finalist själv.</p>



<p>De två stora andelsägaraktörerna Ofcourse KB och Easy KB har tillsammans tre finalister inom sina väggar. Via Ofcourse ägs <strong>Briljant Töll</strong> (e. Day Or Night In) och <strong>Aperfectsavior</strong> (e. Readly Express), medan Easy KB<strong> </strong>står bakom <strong>Calgary Flames</strong> (e. Calgary Games).</p>



<p><strong>Hästägarna bakom E3-finalisterna:</strong></p>



<ol class="wp-block-list">
<li>Briljant Töll – Stall Briljant – Ofcourse</li>



<li>Mezzanine – SRF Stable</li>



<li>Najade Quesnoy – Mattias Djuse Stable AB, Ekolsund</li>



<li>Fusion Blaze – Stall Table 609</li>



<li>Västerbo Sparkly – Peter Fritzdorf, Sollentuna</li>



<li>Thai Medina – B.S. Stables AB, Vimmerby</li>



<li>Rosie Bros – Bros Stables &#038; Trotinc B.V.</li>



<li>Aperfectsavior – Ofcourse KB, Kovland</li>



<li>Ismenis – Fernlunds Travservice AB, Borlänge</li>



<li>Morning Rain – Thomas Lind-Holm, Danmark</li>



<li>Calgary Flames – Stall Pivot – Easy</li>



<li>Diamond In Pj’s – Patrik Olsson, Uddevalla</li>
</ol>



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



<p class="has-drop-cap">E3 ingår i premiechansen och det är 50 procent extra prispengar för de hästar som valde bort att gå premielopp som tvååringar. Samtliga är med i premiechansen utom franskfödda Najade Quesnoy. </p>



<p>Så här fördelas prispengarna:<br><strong>Premiechansen:</strong> 1.500.000-1.000.000-500.000-240.000-160.000-100.000 kr<br><strong>Icke premiechansade:</strong> 1.000.000-500.000-250.000-120.000-80.000-50.000 kr</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/04/powermy-617x492.jpg" alt="" class="wp-image-84146"/><figcaption class="wp-element-caption">My Hedberg när hon skötte Power hos Robert Bergh. Foto: Mia Nilsson</figcaption></figure>



<p class="has-drop-cap">My Hedberg har dubbla hopp som hästskötare i E3-finalerna. Förutom <strong>City Slicker</strong> (e. King City) startar i hingstklassen och här bland stona selar My ut <strong>Aperfectsavior</strong> (e. Readly Express).</p>



<p><strong>Hästskötarna bakom E3-finalisterna:</strong></p>



<ul class="wp-block-list">
<li>My Eriksson – Briljant Töll</li>



<li>Lena Johansson – Mezzanine </li>



<li>Virmantas Lavickas – Najade Quesnoy</li>



<li>Elisa Korhonen – Fusion Blaze</li>



<li>Marlene Matzky – Västerbo Sparkly</li>



<li>Hanna Lindkvist – Thai Medina</li>



<li>Anouk Zwiers – Rosie Bros</li>



<li>My Hedberg – Aperfectsavior</li>



<li>Sara Andersson – Ismenis</li>



<li>Ebba Karbelius – Morning Rain</li>



<li>Lova Lindberg – Calgary Flames</li>



<li>Fredrik Wallin – Diamond In Pj’s</li>
</ul>



<p><strong>Här är ”Det snackas om” för hingstar och valacker:</strong></p>



<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="vC8W3pLveu"><a href="https://sulkysport.se/e3-hv-2026/">E3: Hästen som aldrig stuckit ut</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”E3: Hästen som aldrig stuckit ut” &ndash; Sulkysport" src="https://sulkysport.se/e3-hv-2026/embed/#?secret=txs7VuHzxO#?secret=vC8W3pLveu" data-secret="vC8W3pLveu" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
