
<p class="has-drop-cap">Vintern 2022 tog karriären slut för franske superstjärnan <strong>Face Time Bourbon</strong> (e. Ready Cash). Han kunde se tillbaka på en fantastisk karriär hos Sebastien Guarato med två segrar i Prix d’Amérique som toppnummer, rekordet 1.09,1am* och 3.392.880 euro på bankboken.</p>



<p>Det nya livet som avelshingst provade han på redan 2019 när han betäckte sina första ston. Året efter föddes hans första kull runt om i Europa och i Sverige fick han 35 avkommor. 18 var ston – och tre av dem finns med i lördagens E3-final. Dessutom kryddar ”FTB” med två italienskfödda ston i finalen.<br>Fem av tolv finalister alltså!<br><strong>Käraste Sisu</strong> har visat framfötterna mest av döttrarna med fyra vinster. Ytterligare sex av Face Time Bourbons svenskfödda ston har vunnit lopp.</p>



<p>Sju avelshingstar finns representerade i finalen och bara en av dem vet sedan tidigare hur det känns att vinna. Muscle Hill-dottern <strong>Princess Face</strong> tog hem korta E3 2015 i regi Lutfi Kolgjini. Muscle Hills hopp i år är auktionsdyringen <strong>Elegance Kronos</strong>.</p>



<h2 class="wp-block-heading">Avelshingstar i E3-finalen</h2>



<p><em>Namn (antal 2023) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Explosive Matter</strong> (1) – 2 – No Matter* (0) 2018, No Matter** (1) 2018, </li>



<li><strong>Ken Warkentin</strong> (1) – 3 – Khaki Broline* (0) 2010, Khaki Broline** (0) 2010, Salma Silvio** (0) 2015</li>



<li><strong>Maharajah</strong> (1) – 24 – 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, Kayla Westwood* (3) 2022, Lilian Young* (5) 2022, Caradja* (0) 2022, O’Mara Zon** (2) 2022, Caradja** (3) 2022, Elektra** (0) 2022</li>



<li><strong>Muscle Hill</strong> (1) – 7 – Sparkling Kronos** (0) 2014, <strong>Princess Face</strong>** (1) 2015, Hanna* (0) 2017, Twyla Face* (0) 2018, Bank Wise As* (4) 2020, Global Celebrity** (3) 2021, Mellby Kaxa* (0) 2022</li>



<li><strong>Nuncio</strong> (1) – 2 – Crazy Life** (4) 2022, Decision Maker** (0) 2022</li>



<li><strong>Southwind Frank</strong> (1) – 3 – Impala Am* (6) 2021, Impala Am** (5) 2021, Lollo Trot** (0) 2022</li>
</ul>



<p><em>*deltog i långa E3-finalen<br>**deltog i korta E3-finalen. </em></p>



<p><strong>Fotnot:</strong> Face Time Bourbon (5) har inte haft några avkommor i E3-final tidigare och hans äldsta avkommor är tre år. Tactical Landing (1) har också sin första treåringar till start. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/06/mascatematchmal-617x411.jpg" alt="" class="wp-image-47107"/><figcaption class="wp-element-caption">Dubbla E3-vinnaren Mascate Match. Foto Simon Hagen/Sulkysport</figcaption></figure>



<p class="has-drop-cap">För fjärde gången är långa E3 för ston en del i premiechansen – och förra året var första gången en vinnare kunde kvittera ut dubbla prischecken.<br>2019 års upplaga vanns av finskfödda <strong>Mascate Match</strong> (e. Muscle Mass) och 2021 års segrarinna <strong>Red Lady Express</strong> (e. Readly Express) var inte med i premiechansen, men ifjol blev det full pott för Malmöbon Tord Olsson som äger <strong>Sparven</strong> (e. Bird Parker). Två miljoner kronor skrevs segerchecken ut på sedan Mika Forss kört det av Jörgen Westholm tränade stoet till vinst.</p>



<p>Precis som ifjol står fem av tolv finalister utanför premiechansen. Kvartetten <strong>Eteria, Esperia Fiont, Elisabeth Bar</strong> och <strong>Esmeralda Bez</strong> är födda i Italien, medan ägarna bakom svenskfödda <strong>Coral Coger</strong> (e. Ken Warkentin) valde att inkassera pengar för premielopp som tvååring. Ola Åsebö tog ut stoet i premielopp redan i maj som tvååring ifjol.</p>



<p>Här är prisskalan för de premiechansade hästarna:<br>2.000.000-1.000.000-500.000-240.000-160.000-100.000 kr</p>



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



<p><em>2.140 meter autostart<br>Startspår (far) – Körsven (tränare)</em></p>



<ol class="wp-block-list">
<li>Kinglet Bird (e. Nuncio) – Janne Korpi</li>



<li>Eteria (e. Tactical Landing) – Ulf Ohlsson (Reijo Liljendahl)</li>



<li>Knickers Sisu (e. Southwind Frank) – Magnus A Djuse (Mattias Djuse)</li>



<li>Käraste Sisu (e. Face Time Bourbon) – Mika Forss (Petri Salmela)</li>



<li>Esperia Font (e. Face Time Bourbon) – Gabriele Gelormini (Alessandro Gocciadoro)</li>



<li>Karma Mearas (e. Face Time Bourbon) – Erik Adielsson (Svante Båth)</li>



<li>Elisabeth Bar (e. Face Time Bourbon) – Carl Johan Jepson (Jerry Riordan)</li>



<li>Elegance Kronos (e. Muscle Hill) – Björn Goop</li>



<li>Esmeralda Bez (e. Maharajah) – Alessandro Gocciadoro</li>



<li>Coral Coger (e. Ken Warkentin) – Rikard N Skoglund (Ola Åsebö)</li>



<li>Willa Explosive (e. Explosive Matter) – Mats E Djuse (Johan Untersteiner)</li>



<li>Kitty Mearas (e. Face Time Bourbon) – Örjan Kihlström (Jasmine Ising)</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/2023/06/esmeraldabez-617x333.jpg" alt="" class="wp-image-452521"/><figcaption class="wp-element-caption">Esmeralda Bez och Alessandro Gocciadoro. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">På tal om 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å 26 finaler. Tre segrar till Finland och en till Italien.</p>



<p>I år är den italienska laguppställningen stark med ettan, trean och fyran från Breeders Course-finalen för ston över medeldistans under Elitloppshelgen. Den gången satte Alessandro Gocciadoros <strong>Esmeralda Bez</strong> (e. Maharajah) nosen först i en stenhård slutstrid med i stort sett fyra ston på linje.</p>



<p>Gocciadoro har även loppets fyra <strong>Esperia Font</strong> (e. Face Time Bourbon) till start i E3-finalen. Denna körs av den sedan länge i Frankrike stationerade italienaren Gabriele Gelormini, som för en månad sedan vann Elitloppet med Hohneck!</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 Monkey Ride (e. Express Ride) – Finland</li>



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



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



<li>2019 Mascate Match (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/2023/06/jannekorpi1-617x333.jpg" alt="" class="wp-image-457211"/><figcaption class="wp-element-caption">Janne Korpi har bytt snowboard mot travvagnar på heltid. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Själv har han deltagit i fyra olympiska spel, tagit två världscupsegrar och två VM-brons på snowboard. Den karriären är lagd på is sedan OS i Sydkorea 2018 och istället är det travet som gäller på heltid för 37-årige finländaren Janne Korpi.<br>Och kanske är det inte så konstigt att olympiern slagit sig in på den banan. Pappa är en viss Pekka Korpi – Finlands störste travtränare genom tiderna. Pekka har på sin långa meritlista bland annat tre segrar i E3-finaler med egentränade hästar. Två av dem togs av <strong>Mascate Match</strong> (2019) och den tredje med <strong>Arctic Model</strong> (2014). Dessutom vann Pekka som kusk bakom <strong>Irish Kemp</strong> i den första upplagan 1997.</p>



<p>Nu är det sonens tur. Nuncio-dottern <strong>Kinglet Bird</strong> köpte Janne på Travera-auktionen i oktober ifjol. Fyra starter in i karriären är stoet alltjämt obesegrad och har övertygat så till den grad att prislappen på 160.000 kronor ter sig som rena fyndet.</p>



<p>I uttagningsloppet flög stoet till ledningen, fick bestämma och stack sedan undan på övertygande sätt via 1.10,5 sista kilometern.<br>– Det är något speciellt med den här hästen. Det är som att hon flyger fram; det är otroligt hur lätt hon springer såhär fort. Det är helt otroligt hur lätt hon sprang 1.08,5 sista 500 meterna. Hon är utan tvekan en av de mest talangfulla hästar vi har haft, sade Janne Korpi efter försökssegern.</p>



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



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



<p>Av tränarna bakom årets tolv finalister har Petri Salmela och Svante Båth vunnit långa upplagan med ston tidigare. Salmela var mannen bakom 2009 års vinnare <strong>My Love di Quattro</strong> (e. Love You), medan Båth plockade fram <strong>Barbro Kronos</strong> (e. Trixton) för tre år sedan.<br>Silverstofyran <strong>Käraste Sisu</strong> (e. Face Time Bourbon), som är mest rutinerad i finalfältet med tolv starter (4-3-2), vann sitt E3-försök och är Salmelas bidrag.<br>Svante Båth ställer hoppet till <strong>Karma Mearas</strong> (e. Face Time Bourbon), vars mamma <strong>Nice Kronos</strong> (e. Viking Kronos), 1.11,6ak/657.619 kr, vann försök till korta E3 2010 och slutade sedan fyra i finalen i regi Lutfi Kolgjini. Nice Kronos kvalade även in till korta E3 och var också finalist i Drottning Silvias Pokal året efter. Alla dessa tre finaler vanns av en viss Tamla Celeber.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/knickerssisu1-617x333.jpg" alt="" class="wp-image-449452"/><figcaption class="wp-element-caption">Glädjescener efter att Knickers Sisu vunnit ASVT Trottex Auktionslopp för ston. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Solvallatränaren Mattias Djuse har 35 treåringar i träning och den som visat mest är stoet <strong>Frustration</strong> (e. Fourth Dimension), som slutade tvåa i Svensk Uppfödningslöpning och Svampen som tvååring. Hon vann sitt försök till Uppfödningsloppet på vassa 1.13,0a/1.640 meter!<br>I år gjorde hon en start i februari – vann ev avdelning i Margaretas Tidiga Unghästserie – och har sedan fått en paus och tränats för uppgifter senare under säsongen. 1.710.000 kronor har hon sprungit in inför sin comeback på Solvalla på onsdag.</p>



<p>Tränare Djuses E3-hopp bland stona är istället <strong>Knickers Sisu</strong> (e. Southwind Frank), som inlett tävlingskarriären fint med fyra segrar. E3-försöket togs hem på snabbaste tiden av alla vinnare: 1.12,6a/2.140 meter!</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/eteriauo-617x333.jpg" alt="" class="wp-image-457226"/><figcaption class="wp-element-caption">Reijo Liljendahl-tränade Eteria och Ulf Ohlsson vann första uttagningsloppet till E3. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Bland delägarna i avelshingstdominanten Face Time Bourbon finns italienske hästägaren Renato Bruni, som genom sitt bolag Bruni Racing Team AB, Bjärred, satsat hårt på hästar på svensk mark de senaste åren.<br>Det började på allvar med toppstoet <strong>Vamp Kronos</strong> (e. Ready Cash), 1.11,2ak*/4.576.377 kr, som vann Stosprintern, slutade tvåa i Stochampionatet och trea i Breeders Crown. I E3-sammanhang vann hon försök till långa E3, men gjorde bort sig med galopp i finalen, liksom i försök till korta E3.<br>Hos Jerry Riordan finns nu dubbelmiljonärskan <strong>Dea Grif</strong> (e. Varenne), som vann korta E3 förra året och startar i Sprintermästaren på torsdag.</p>



<p>I årets E3-final får Bruni rikta blickarna mot två hästar: Reijo Liljendahl-tränade <strong>Eteria</strong> (e. Tactical Landing) och Riordan-tränade <strong>Elisabeth Bar</strong> (e. Face Time Bourbon). <br>Delägda Eteria har inlett tävlingskarriären mycket lovande med fyra segrar och tredjeplatsen i Breeders Course-finalen på fem starter. Liljendahl ropade in henne för 40.000 euro på ITS-auktionen i Italien som ettåring.<br>– Hon komme från Tactical Landings första kull, vilket bara det var intressant i sig. Exteriört var hon väldigt fin, jag gillade hennes temperament och bestämde mig för att gå för henne, sade Reijo om auktionsköpet till Sulkysport inför Elitloppshelgen.</p>



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



<p class="has-drop-cap">Mer än hälften av de tolv finalisterna har bjudits ut på auktion som unghästar och dyringarna är Renato Brunis andra finalist <strong>Elisabeth Bar</strong> (e. Face Time Bourbon) samt Björn Goop-tränade <strong>Elegance Kronos</strong> (e. Muscle Hill).</p>



<p>Den sistnämnda ägs av Jean Pierre Barjon – ordförande i franska travförbundet! Barjon har i nuläget åtta hästar i svensk träning, hos Goop respektive Timo Nurmos. Barjons största seger på svensk mark är triumfen i Svensk Uppfödningslöpning 2014 för <strong>Mister J.P.</strong> (e. Taurus Dream), 1.13,0al/3.325.500 kr, i Björn Goops träning.</p>



<p><strong>Så mycket kostade E3-finalisterna på auktion:</strong></p>



<ul class="wp-block-list">
<li>Elisabeth Bar – 140.000 euro – ITS-auktionen 2021</li>



<li>Elegance Kronos – 1.400.000 kr – Sweden International Yearling Sale 2021</li>



<li>Eteria – 40.000 euro – ITS-auktionen 2021</li>



<li>Esperia Font – 33.000 euro – ITS-auktionen 2021</li>



<li>Esmeralda Bez – 21.000 euro – Anact/Asta Puledri 2021</li>



<li>Kinglet Bird – 160.000 kr – Courantauktionen 2022 (som tvååring)</li>
</ul>



<p><em>Knickers Sisu var utbjuden på Elitauktionen 2021, där hon ropades tillbaka för 150.000 kronor.</em></p>



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



<p class="has-drop-cap">Uppfödarna Sisyfos Breeders AB i Sigtuna och Snogarps Gård i Ystad kan verkligen sträcka på sig lite extra inför E3-finalen för ston. Uppfödarna har nämligen plockat fram två finalister vardera!</p>



<p>Sisyfos Breeders ropade tillbaka <strong>Knickers Sisu</strong> (e. Southwind Frank) på Elitauktionen, men sålde henne senare. Däremot har uppfödarna behållt <strong>Käraste Sisu</strong> (e. Face Time Bourbon).<br>Snogarps Gård har privat auktion av sina uppfödningar som säljs på sommaren som föl och både <strong>Karma Mearas</strong> (e. Face Time Bourbon) och <strong>Kitty Mearas</strong> (e. Face Time Bourbon) fann nya ägare sommaren 2020.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/kittymearasokm230416adamstromstalltz-617x400.jpg" alt="" class="wp-image-431366"/><figcaption class="wp-element-caption">Kitty Mearas. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Fyra stolta mödrar står bakom hästarna och guldkornet i samlingen är <strong>Khao Manee</strong> (e. Muscles Yankee) på Snogarps Gård. Den 18-åriga damen utsågs redan 2021 till Elitsto i svensk avel och det är inte så konstigt med avkommor som <strong>Honey Mearas </strong>(e. Readly Express), 1.10,6am<em>/</em>9.261.973 kr, <strong>Darling Mearas </strong>(e. Cantab Hall), 1.08,2ak/7.337.561 kr, och <strong>Milady Grace</strong> (e. Ready Cash), 1.12,2am*/3.468.000 kr.</p>



<p>Jasmine Ising-tränade <strong>Kitty Mearas</strong> (e. Face Time Bourbon) är Khao Manees bidrag i E3-finalen. Stoet köptes som föl av Philip Konsulting HB, men när ägaren Leif Bengtssons travsatsning lades ned förra året såldes alla hans hästar. <br>– Vi fick chansen att köpa loss Kitty Mearas från Leif Bengtsson och hästmässigt är det vår livs största investering. Hon var väldigt dyr, men vi fick ett bra pris och det är Leifs förtjänst att vi står här idag, sade Jasmin Isings sambo Patrick Fernlund efter stoets seger på Solvalla i april.</p>



<h2 class="wp-block-heading">Människorna bakom E3-finalisterna</h2>



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



<ol class="wp-block-list">
<li>Kinglet Bird – JJK Sports Oy, Finland – Am Bloodstock AB, Stockholm</li>



<li>Eteria – Bruni Racing Team AB, m fl – Scud. Sant&#8217; Andrea S.R.L., Italien</li>



<li>Knickers Sisu – Kulturinvest I Sverige AB, Stockholm – Sisyfos Breeders AB, Sigtuna</li>



<li>Käraste Sisu – Sisyfos Breeders AB, Sigtuna – Sisyfos Breeders AB, Sigtuna</li>



<li>Esperia Font – Cecchi Leonardo m fl, Italien – Dream Ferm SRL &#038; Allev.Le Fontantette</li>



<li>Karma Mearas – Olof Brodin (Chartering) AB,Sollentuna – Snogarps Gård AB, Ystad</li>



<li>Elisabeth Bar – Bruni Racing Team AB, Bjärred – Az. Agr. L. Truccone &#038; Roberto Bruera</li>



<li>Elegance Kronos – Ecurie Jean-Pierre Barjon, Frankrike – Dvbk International AB, Enköping</li>



<li>Esmeralda Bez – Scud Pink &#038; Black S.R.L., S Sernicoli – Alessia Bezzecchi, Italien</li>



<li>Coral Coger – Åsebö Agro AB &#038; Ola Åsebö – Vamero AB, Askim</li>



<li>Willa Explosive – BN Dental Holding AB, Umeå – BN Dental Holding AB, Umeå</li>



<li>Kitty Mearas – Ising Racing AB, Borlänge – Snogarps Gård AB, Ystad</li>
</ol>



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



<p class="has-drop-cap">Maharajah närmar sig Alf Palema som den avelshingst som haft flest startande avkommor i E3 för ston och <strong>Esmeralda Bez</strong> blir hans 25:e finalist. Fortfarande väntar Sveriges senaste champion på första segern i loppet. Det har blivit fyra andraplatser som bäst hittills.</p>



<p><strong>Flest startande avkommor i E3 för ston:</strong><br><em>Hingst (antal) – Resultat</em></p>



<ul class="wp-block-list">
<li>Alf Palema (26) – 1-2-2</li>



<li>Maharajah (24) – 0-4-5</li>



<li>Viking Kronos (20) – 0-0-2</li>



<li>Spotlite Lobell (19) – 1-1-3</li>



<li>Super Arnie (19) – 0-2-2</li>



<li>Express Ride (18) – 3-2-2</li>



<li>Ready Cash (15) – 0-0-1</li>



<li>Varenne (15) – 4-1-0</li>



<li>Scarlet Knight (11) – 1-2-2</li>



<li>Lindy’s Crown (10) – 1-0-1</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/2023/01/hardtimespris-617x333.jpg" alt="" class="wp-image-402859"/><figcaption class="wp-element-caption">Ola Åsebös norske Kriterievinnare Hard Times och Ulf Ohlsson efter segern i Solvalla Grand Prix 2018. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Han har seger i norska Kriteriet på meritlistan, men frågan är om det inte går bättre än någon gång tidigare för norrmannen Ola Åsebö, som huserar på den gård i Kovland utanför Sundsvall där Christer Nylander verkade med stor framgång under flera decennier.</p>



<p>Åsebö har tio hästar i stallet, varav fem som startat, och har med råge passerat miljonen inkört till stallet i år. Så sent som i tisdags segrade forne norske Kriterievinnaren <strong>Hard Times</strong> lillasyster <strong>Tigermind</strong> (e. Coktail Jet) på Solvalla.<br>En dubblering av årets prispengar kan det bli om <strong>Coral Coger</strong> (e. Ken Warkentin) går i topp i E3-finalen tillsammans med Rikard N Skoglund.</p>



<p>Coral Coger var en av sju E3-finalister som tävlade redan som tvååringar. Sex starter gav tre andrapris och två tredjeplatser. På priskontot tickade det in 145.000 kronor för stoet vars främsta merit är andraplatsen i finalen av Norrlands Elitserie för tvååringar.<br>– Hon fick tävla som tvååring eftersom hon varit så stänkrädd och hon har utvecklats fint av loppen. Kanske är det något för årgångsloppen i år? funderade Åsebö i en intervju med Sulkysport i januari.<br>Och visst har det blivit så! Fem starter, tre segrar och aldrig sämre än trea är årets resultat där största segern togs i Vårfavoriten för ston på Solvalla i april.</p>



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



<p class="has-drop-cap">Johan Untersteiner har fem segrar i E3 som kusk, däribland en med Roger Walmann-tränade <strong>Mellby Briolett</strong> (e. Going Kronos) i långa E3-finalen för ston för tio år sedan. Som tränare väntar Johan forfarande på första segern.<br>Helgens möjlighet kommer med <strong>Willa Explosive</strong> (e. Explosive Matter), som får Mats E Djuse i sulkyn i finalen. Stoet hade samma kusk i Breeders Crown-försök på Solänget i maj och visade att både långresa och norrlandsluft inte är några problem. Hon säkrade nämligen en plats i BC-semifinalerna i höst genom att sluta trea.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/knickerssisu2-617x333.jpg" alt="" class="wp-image-464825"/><figcaption class="wp-element-caption">Mattias Djuse-tränade Knickers Sisu och skötaren Ida Rudelöv. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Här är skötarna bakom årets finalister i långa E3 för ston:</strong></p>



<ul class="wp-block-list">
<li>Kinglet Bird – Jenina Hamari</li>



<li>Eteria – Pernilla Sundling</li>



<li>Knickers Sisu – Ida Rudelöv</li>



<li>Käraste Sisu – Rebecca Nisonen</li>



<li>Esperia Font – Ludwig Wickman</li>



<li>Karma Mearas – Lilly Lundgren</li>



<li>Elisabeth Bar – Heli Harrimaa</li>



<li>Elegance Kronos – Jenny Nordensson</li>



<li>Esmeralda Bez – Andrea Ferrara</li>



<li>Coral Coger – Ola Åsebö</li>



<li>Willa Explosive – Wilma Karlsson</li>



<li>Kitty Mearas – Hanna Holmberg</li>
</ul>



<p>	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									Vinnare av långa E3 ston								</h3>
														<div class="content">
								<strong>År – Häst – Kusk – Tränare – Tid</strong>
<ul>
 	<li>1997 – <strong>Mack Action Ås</strong> – Örjan Kihlström – Olle Goop – 1.15,6a</li>
 	<li>1998 – <strong>Montana Chill</strong> – Erik Adielsson – Tomas Malmqvist – 1.16,3a</li>
 	<li>1999 – <strong>Monkey Ride</strong> – Tuomas Korvenoja – Tuomas Korvenoja – 1.15,1a</li>
 	<li>2000 – <strong>Ezamble</strong> – Erik Adielsson – Tommy Hanné – 1.14,5a</li>
 	<li>2001 – <strong>Pine Dust</strong> – Örjan Kihlström – Stefan Hultman – 1.15,5a</li>
 	<li>2002 – <strong>Rae Boko</strong> – Jorma Kontio – Markku Nieminen – 1.16,1a</li>
 	<li>2003 – <strong>Giant Diablo</strong> – Örjan Kihlström – Roger Walmann – 1.15,0a</li>
 	<li>2004 – <strong>Needles n’Pins</strong> – Lutfi Kolgjini – Lutfi Kolgjini – 1.14,7a</li>
 	<li>2005 – <strong>Joy Ås</strong> – Björn Goop – Olle Goop – 1.15,3a</li>
 	<li>2006 – <strong>Vala Boko</strong> – Jorma Kontio – Timo Nurmos – 1.14,2a</li>
 	<li>2007 –<strong> Lie Detector</strong> – Örjan Kihlström – Stefan Hultman – 1.16,5a</li>
 	<li>2008 – <strong>Mystical Ann</strong> – Åke Svanstedt – Åke Svanstedt – 1.15,4a</li>
 	<li>2009 – <strong>My Love di Quattro</strong> – Ulf Ohlsson – Petri Salmela – 1.13,5a</li>
 	<li>2010 – <strong>Tamla Celeber</strong> – Torbjörn Jansson – Roger Walmann – 1.14,1a</li>
 	<li>2011 – <strong>Britannia</strong> – Robert Bergh – Robert Bergh – 1.15,1a</li>
 	<li>2012 – <strong>System Performance</strong> – Stefan Melander – Stefan Melander – 1.14,1a</li>
 	<li>2013 – <strong>Mellby Briolett</strong> – Johan Untersteiner – Roger Walmann – 1.14,5a</li>
 	<li>2014 – <strong>Arctic Model</strong> – Pekka Korpi – Pekka Korpi – 1.13.9a</li>
 	<li>2015 – <strong>Timbal</strong> – Robert Bergh – Robert Bergh – 1.12,5a</li>
 	<li>2016 – <strong>Uncertain Age</strong> – Christoffer Eriksson – Tomas Malmqvist – 1.13,5a</li>
 	<li>2017 – <strong>Violet Bi</strong> – Jim Oscarsson – Jim Oscarsson – 1.13,7a</li>
 	<li>2018 – <strong>Zara Kronos</strong> – Joakim Lövgren – Joakim Lövgren – 1.12,7a</li>
 	<li>2019 – <strong>Mascate Match</strong> – Pekka Korpi – Pekka Korpi – 1.12,3a</li>
 	<li>2020 – <strong>Barbro Kronos</strong> – Erik Adielsson – Svante Båth – 1.13,8a</li>
 	<li>2021 – <strong>Red Lady Express</strong> – Carl Johan Jepson – Christian Persson – 1.12,6a</li>
 	<li>2022 – <strong>Sparven</strong> – Mika Forss – Jörgen Westholm – 1.13,6a</li>
 	<li>2023 – <strong>Coral Coger</strong> – Rikard N Skoglund – Ola Åsebö – 1.12,9a</li>
 	<li>2024 – <strong>Screen Time Limit</strong> – Ulf Ohlsson – Reijo Liljendahl – 1.13,3a</li>
</ul>							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
