
<p class="has-drop-cap wp-block-paragraph">1Är tuffingarna från flera tillägg bara bäst, eller går det att hålla undan från startfållan? Sulkysport har synat vinnarna de senaste 25 åren – från <strong>Etain Royal</strong> (e. Ulf d’Ombree) till <strong>Izoard Vedaquais</strong> (e. Bird Parker) – och utfallet visar att de rikaste hästarna har störst segerchans.</p>



<p class="wp-block-paragraph">Av de 25 senaste upplagorna har vinnaren hittats på startfållan längst bak fler än hälften av gångerna, 13 vinnare. Åtta hästar har vunnit från mellanvolten, men de senaste segern därifrån ligger elva år tillbaka i tiden, när Elitloppshästen Mellby Knekts pappa <strong>Mellby Viking</strong> (e. Viking Kronos) segrade 2014. Från startvolten har vara fyra av 25 vinnare hittats.</p>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Harper Hanover								</h3>
<div class="content">
<p class="wp-block-paragraph"><em>Hingst född 1932 e. Peter Volo-Sister Bertha e. Dillon Axworthy</em><br /><strong>Rekord:</strong> 1.19,1 (7 år)<br /><strong>Prissumma:</strong> 101.755 kr<br /><strong>Resultat (Europa):</strong> 155 st: 55-32-23<br /><strong>Uppfödare:</strong> Hanover Shoe Farms<br /><strong>Ägare:</strong> Hugh M. ”Doc” Parshall, Hanover Shoe Farms, Wilhelm Billberg (Hr Billis) 1935-1937, Einar Wendel (Stall Hanover) 1937-1940 och John Pettersson (Stall Reymers) 1940-1942.<br /><strong>Tränare: </strong>Hugh M. ”Doc” Parshall, Wilhelm Billberg (a), Oscar Persson, Calle Holmström, Peder Paul Nielsen, Oscar Persson och Ernst Johan/Gunnar Nordin.<br /><strong>Större segrar:</strong> C.Th. Ericssons Memorial 1939, Jägersros Poänglöpning 1939 och Åby Stora Pris 1939. </p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p class="wp-block-paragraph">Årets upplaga då? Förhandsfavoriten <strong>Ibiki de Houelle</strong> (e. Love You) stökade och krånglade när han skulle flyga från Frankrike igår. Hästen släpptes inte ombord av veterinär och är struken från dagens lopp.<br>Trots frånfallet startar hälften av deltagarna från dubbla tillägg, 3.180 meter, och rikast i sällskapet är tiofaldiga miljonärskan <strong>Inmarosa</strong> (e. Amiral Sasha).</p>



<p class="wp-block-paragraph"><strong>Vinnarnas startvolt i Harper Hanovers lopp:</strong></p>



<ul class="wp-block-list">
<li>3.140 meter – fyra vinnare: Cool Amber, Max Flukt, Scargel, Nougat Ås.</li>



<li>3.160 meter – åtta vinnare: Max Flukt, Millstone’s Eager, Yarrah Boko, Yellow Eden, Winning Love, Mellby Viking, Platon Face, Eilis.</li>



<li>3.180 meter – 13 vinnare: Etain Royal, Flambeau des Pins, Flambeau des Pins, Jess Luxor, Millord de Millerey, Indigious, Bird Parker, Sauveur, Moni Viking, Wild Love, Diable de Vauvert, Eric The Eel, Izoard Vedaquais.</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/05/24v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Solvalla.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/5feliciazet-617x333.jpg" alt="" class="wp-image-588500"/><figcaption class="wp-element-caption">Daniel Redén-tränade Felicia Zet och Örjan Kihlström vid segern för ett år sedan. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Solvallas uppvärmning inför Elitloppsdagen bjuder på rikstotofinaler och nyinstiftade Jovialitys lopp har tagit över i stonas högsta klass från Lady Snärt. Förra året namngav denna ett försök i stoeliten, medan det i Jovialitys namn nu blir en regelrätt final i Diamantstoet, prishöjd till en halv miljon till vinnaren.</p>



<p class="wp-block-paragraph">Fast en sak är sig lik i loppet. Fjolårets vinnare av Lady Snärts lopp <strong>Felicia Zet</strong> (e. Ready Cash) är även med i Jovialitys lopp. Ifjol vann hon på 1.09,9a/1.640 meter från ledningen, men idag inleder hon från andra ledet i spårtrappan. <br>– Hon var inte på topp senast. Vi har varit hos veterinären efter det och hittade ganska mycket att göra. Hon känns helt annorlunda här hemma efter det. Jag tycker detta blir en spännande start. Jag tror till och med att hon kommer vara annorlunda redan i värmningen. Hon har ju alltid sprungit väldigt speciellt, men vi hittade nya saker att göra på henne och jag tycker att hon känns bättre mellan intervallerna än tidigare så det ska bli väldigt spännande, säger Daniel Redén till Stall Zets hemsida.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-lordag-harpers-hojdaren/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysport stora tipsgenomgång med analyser, spikar, drag och systemförslag till V75.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/3alwaysek-617x333.jpg" alt="" class="wp-image-588483"/><figcaption class="wp-element-caption">Always Ek och Alessandro Gocciadoro vid segern i försöksloppet till Sweden Cup på 1.08,6a/1.640 meter.  Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Det började som ett heatlopp, gjordes om till lilla Elitloppet med försök och final och har varierade när det gäller antalet hästar och försök.<br>Tre försök med sju hästar i varje följs av final dit de tre främsta kvalificerar sig är det som gäller numera. Detta upplägg hade premiär 2016 efter många år med Elitloppstouch över loppet, alltså två försök och final. Åren runt 2000 kördes också tre försök. </p>



<p class="wp-block-paragraph">Stefan Melander-tränade <strong>Volstead</strong> (e. Cantab Hall) travade 1.09,3a/1.640 meter när han vann tillsammans med Örjan Kihlström 2017 och satte löpningsrekordet. Den tiden tangerades av Alessandro Gocciadoros <strong>Bengurion Jet </strong>(e. Maharajah) i 2023 års final, men pressades rejält på den blixtsnabba Solvallaovalen förra året. Då slog nämligen stallkamraten – och årets Elitloppsdeltagare – <strong>Always Ek</strong> (e. Filipp Roc) till med vinst på 1.08,6a/1.640 meter tillsammans med sin tränare Alessandro Gocciadoro. I finalen blev det dock förlust mot <strong>Missle Hill</strong> (e. Muscle Hill), som travade 1.09,5.<br>Att det var en fartfest förra året rådde inga tvivel om och samtliga tre försöksvinnare och finalvinnaren Missle Hill travade under 1.10 i sina segerlopp.</p>



<p class="wp-block-paragraph">Årets tre försök till Sweden Cup har samlat en räcka topphästar med gott om miljoner på bankboken. Alessandro Gocciadoro tränar sju (!) av 21 hästar och en av dem är jänkaren <strong>Click Bait</strong> (e. Cantab Hall),som köptes från Stefan Melander i samband med Hugo Åbergs Memorial förra sommaren.</p>



<p class="wp-block-paragraph">Hos Gocciadoro inledde han med att vinna Grupp I-loppet Campionato Europeo i Cesena, men sedan dess har det varit fritt från framgångar.<br>– Click Bait hade en lugn vinter med vila och arbete som avelshingst. Han gick rakt ut i Lotterian i comebacken och med tanke på den paus han hade haft så tycker jag han gjorde det ganska bra i de loppen. Det tog emot sista 50 meterna, men det var inte konstigt. Spår ett är perfekt och han har mycket god chans att ta ledningen, säger Alessandro Gocciadoro på sin intervjusida.</p>



<p class="wp-block-paragraph"><strong>Alla segertider under 1.10 i Sweden Cup</strong><br><em>År (lopp) – Vinnare (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2024 (försök) – Always Ek (e. Filipp Roc) – Alessandro Gocciadoro – 1.08,6</li>



<li>2024 (försök) – Missle Hill (e. Muscle Hill) – Örjan Kihlström(Daniel Redén) – 1.09,2</li>



<li>2017 (final) – Volstead (e. Cantab Hall) – Örjan Kihlström (Stefan Melander) – 1.09,3</li>



<li>2023 (final) – Bengurion Jet (e. Maharajah) – Alessandro Gocciadoro – 1.09,3</li>



<li>2014 (försök) – Mosaique Face (e. Classic Photo) – Lutfi Kolgjini – 1.09,5</li>



<li>2017 (försök) – Breidabliks Nubbe (e. Lindy Lane) – Conrad Lugauer – 1.09,5</li>



<li>2024 (final) – Missle Hill (e. MuscleHill) – Örjan Kihlström(Daniel Redén) – 1.09,5</li>



<li>2016 (försök) – Pascia’ Lest (e. Varenne) – Björn Goop (Fabrice Souloy) – 1.09,6</li>



<li>2013 (final) – Owen’s Club (e. Duke Of York) – Pietro Gubellino – 1.09,7</li>



<li>2017 (försök) – Volstead (e. Cantab Hall) – Örjan Kihlström (Stefan Melander) – 1.09,7</li>



<li>2018 (försök) – Charrua Forlan (e. Up Front Larry) – Hans-Owe Sundberg – 1.09,7</li>



<li>2019 (final) – Queer Fish (e. Varenne) – Ulf Eriksson (Magnus Träff) – 1.09,7</li>



<li>2024 (försök) – Diamond Truppo (e. Varenne) – Alessandro Gocciadoro – 1.09,8</li>



<li>2014 (final) – Mosaique Face (e. Classic Photo) – Lutfi Kolgjini – 1.09,9</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/sandraeriksson1-617x333.jpg" alt="" class="wp-image-226435"/><figcaption class="wp-element-caption">Sandra Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4På Umåker den 9 april var Bodentränaren Sandra Eriksson inblandad i en svår olycka, där Sandra åkte i backen när hon körde <strong>Ocorone Sunrise</strong> (e. Royal Fighter) och blev liggande på banan. Hon togs om hand av ambulanspersonal och fördes till Norrlands universitetssjukhus i Umeå, där det konstaterades huvudskador.</p>



<p class="wp-block-paragraph">1,5 månader senare är hon tillbaka som en vinnare på hemmabanan – tre gånger om dessutom. Sandra hade nämligen en klang-och-jubel-föreställning igår kväll, där hon körde tre lopp och vann alla!</p>



<p class="wp-block-paragraph">Segerhästarna var i tur och ordning <strong>Nightwish River</strong> (e. Propulsion), <strong>King of Djazz</strong> (e. Zola Boko) och <strong>J.M.’s Caviar</strong> (e. S.J.’s Caviar).<br>– Jag har ett tag kvar innan jag är tillbaka och det kommer att ta tid. Samtidigt har jag fått den bästa hjälp jag kan få och de tycker att jag ska utsätta mig för det i lämplig mängd. Jag ska ta det försiktigt, men det är fantastiskt kul att vinna, sade Sandra i vinnarcirkeln efter första vinsten i comebacken.</p>



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



<p class="has-drop-cap wp-block-paragraph">5Flera svensktränade travare dyker upp på Enghien (kl. 12.48) idag och i Prix du Rhone (€71.000) startar Nicolas Bazire duon <strong>Killiam Fromentro</strong> (e. Villiam) och <strong>Coral Coger</strong> (e. Ken Warkentin). Han lämnar över tömmarna till pappa Jean-Michel respektive Tristan Ouvrie i ett lopp över 2.150 meter med autostart och där det lockas med 31.950 euro till vinnaren. </p>



<p class="wp-block-paragraph">Senare under dagen jagar Timo Nurmos-tränade <strong>Gaylord Am </strong>(e. Muscle Hill) andra raka segern i Prix de l’Obelisque (€75.000) och Matthieu Abrivard sitter i sulkyn. Johan Untersteiner har <strong>Toto Barosso</strong> (e. Ready Cash) till start i medeldistansloppet som startas med bil och den tyskfödde travaren körs av Franck Ouvrie. Vinnarens belöning är 33.750 euro. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/enghien-2025-05-24/" target="_blank" rel="noreferrer noopener">Startlistorna till Enghiens tävlingar hittar ni här.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/mybffannee952025lisa-617x346.jpg" alt="" class="wp-image-717640"/><figcaption class="wp-element-caption">Hambletonianvinnaren Karls lillasyster My Bff Annee. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Meadowlands drar igång med första försöksomgången i New Jersey Sire Stakes ($25.000) för treåringar och det är gott om blågula tränare som har hästar till start. </p>



<ul class="wp-block-list">
<li><strong>Per Engblom: </strong>Evans Per Fect War (e. Six Pack), The Brodster (e. Propulsion)</li>



<li><strong>Marcus Melander: </strong>Get It All (e. Muscle Hill), Go Boom (e. Muscle Hill), Mountcastle (e. Muscle Hill), Sky Legacy (e. Walner), </li>



<li><strong>Jim Oscarsson: </strong>Sound Judgment (e. Muscle Hill)</li>



<li><strong>Åke Svanstedt: </strong>Dusty D Lite (e. Walner), My Honor (e. Muscle Hill), Santa Caterina (e. Walner), What A Bid Hanover (e. Muscle Hill)</li>



<li><strong>Nancy Takter: </strong>Champagne Problems (e. Tactical Landing), Deja Blu (e. Muscle Hill), Kendra (e. Walner), My Bff Annee (e. Tactical Landing), Top Gun Hanover (e. Walner), Travolta Hanover (e. Muscle Hill)</li>
</ul>



<p class="wp-block-paragraph">Vidare startar sex svensktränade travare i ett försök i Miss Versatility ($40.000) för ston. Åke Svanstedt startar trion <strong>Dial Square</strong> (e. Ready Cash), <strong>Nelson Bright Eagle</strong> (e. Bold Eagle) och <strong>Prominence</strong> (e. Father Patrick), medan <strong>Bravo Angel</strong> (e. Readly Express), <strong>Chake</strong> (e. Donato Hanover) och <strong>Golden Rain</strong> (e. Bold Eagle) selas ut från Per Engbloms stall. </p>



<p class="wp-block-paragraph"><a href="https://racing.ustrotting.com/goto.aspx?target=12,99467" target="_blank" rel="noreferrer noopener">Här hittar du samtliga startlistor till lördagens tävlingar på Meadowlands. </a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Franske mångmiljonären <strong>Dorgos de Guez</strong> (e. Romcok de Guez) bjöds in till Elitloppet 2021 som ett av de största dragplåstren. Jean Michel Bazires häst visade finfin form inför travfesten på Solvalla, men knappt två veckor före det stora slaget på Solvalla hoppade Bazire och Dorgon de Gues av Elitloppet. <br>– Det är speciellt aktuella händelser som förbjuder mej att delta i Elitloppet eftersom diverse svenska tävlingsregler är fullkomligt obegripliga, sade Bazire i franska Paris Turf om beslutet.</p>



<p class="wp-block-paragraph">När Dorgos de Guez närmade sig åldersstrecket i hemlandet flyttade han till Norge och Frode Hamre 2023 och igår kom andra segern på 17 försök i nya hemlandet när han vann ett montélopp på Momarken på 1.16,3/2.700 meter tillsammans med Helene Kolle. Segerpremien var ljumma 18.000 norska kronor.</p>



<p class="wp-block-paragraph">Dorgos du Guez gjorde livets 100:e start och tog seger 34. I prispengar har det blivit 12.258.102 norska kronor.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Bästa startfållan för att vinna Harpers
Vinnarna i Harpers – startfålla för startfålla. Alla segertider under 1.10 i Sweden Cup. Sandra tog trippel i comeback efter 1,5 månader. Svenska hopp i Paris.
Detta och mer i lördagsmorgonens nyhetssvep.
Detta och mer i lördagsmorgonens nyhetssvep.
