
<p class="has-drop-cap">1En Elitloppstvåa på varmblodssidan. En Elitkampstrea bland kallbloden. Det är dukat för fartfester i Bollnäs ikväll (första start 18.30) med ett sprinterlopp vardera för båda raserna. Tyvärr ser inte vädret ut att vara med på rekordtider, runt fyra plusgrader och lite regn i luften är prognosen, men Bollnästravets oval är ju världsrekordsnabb och visst kommer det att gå undan ikväll.</p>



<p>Den 14 augusti 2015 skrev <strong>Delicious U.S. </strong>(e. Cantab Hall), 1.08,6ak*/6.581.572 kr, in sig i historiebäckerna med besked när hon satte världsrekord för äldre ston över sprinterdistans på tusenmetersbana med fenomenala noteringen 1.08,6a/1.640 meter i just Bollnäs.</p>



<p>Den 13 augusti 2020 var<strong> Odd Herakles</strong> (e. Moe Odin), 1.18,4ak*/12.950.229 NOK, förkrossande överlägsen tillsammans med Jorma Kontio när han – utan att vara bottnad – dansade runt på 1.18,5a/1.640 meter i Bollnäs.</p>



<p>Två fantastiska noteringar som naturligtvis fortsatt står som banrekord på hälsingebanan. Ikväll är 2022 års Elitloppstvåa <strong>Hail Mary</strong> (e. Googoo Gaagaa) med i snabbloppet Queer Fishs lopp – en hyllning till Sweden Cup-vinnaren 2019 – och ställs mot sex konkurrenter.</p>



<p>Gunnar Melanders trefaldige svenske mästare <strong>Månlykke A.M. </strong>(e. Månprinsen A.M.) segrade direkt i årsdebuten på Romme i påskas i första starten med Sveriges kusketta Magnus A Djuse i sulkyn. Magnus sitter bakom Månlykke A.M. även ikväll när hästen ska fortsätta vässa formen mot Elitkampen på Solvalla på Elitloppsdagen, där en miljon kronor väntar vinnaren.</p>



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



<p class="has-drop-cap">2Umåker (första start 18.20) delar kvällens expresstrav och bjuder på en hel del godbitar och höga prissummor. I Damklubbens Stora Fyraåringspris med sexsiffrig segercheck dyker långa E3-vinnaren <strong>Coral Coger</strong> (e. Ken Warkentin) upp mot bland andra <strong>Käraste Sisu</strong> (e. Face Time Bourbon), som vann E3 Chansen och kvalade in till både Oaks och Breeders Crown förra året. </p>



<p>Daniel Wäjerstens fyrfaldige miljonär <strong>Global Badman</strong> (e. Yield Boko) gör årsdebut i snabbloppet. Han startade i samma lopp förra året (fyra) och följde sedan upp med att vinna gulddivisionsloppet Guldbjörken två veckor senare, hästens största seger ifjol. Bland motståndarna finns veteranerna<strong> From The Mine</strong> (e. From Above) och <strong>Selmer I.H. </strong>(e. Love You).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/04/globalbadman-617x333.jpg" alt="" class="wp-image-291057"/><figcaption class="wp-element-caption">Daniel Wäjerstens Global Badman. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Umåkermästaren har varit en följetong under vintern och våren med tre försöksomgångar, som lett fram till kvällens final där 80.000 kronor väntar vinnaren. Hästar i tre klasser har samlat poäng för att nå finalen som avgörs som ett flerklasslopp med hästar med fem hästar vardera på tre volter.</p>



<p>En av försöksvinnarna är Umåkeramatören Lars-Erik Perssons <strong>Arpi Broline</strong> (e. Quite Easy), som vunnit två av tre försök i ”mellanklassen” och som vanligt körs av Jan Norberg.</p>



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



<p class="has-drop-cap">3Fredagen på svensk travmark inleds på Jägersro (första start 12.20), där sju spårtrappor – för hästar upp till en miljon kronor intjänat – samsas med ett välfyllt treåringslopp för ston.</p>



<p>I högsta klassen dyker flera rikstotomeriterade hästar upp, som <strong>Farfars Dream </strong>(e. Maharajah), som gör andra starten i Per Nordströms regi efter flytt från André Eklundh, segervane <strong>Brady D.E. </strong>(e. Love You) och formstarke<strong> Cubalibre Jet</strong> (e. Trixton) är några av deltagarna.</p>



<p>En annan är danske femåringen <strong>Henrik Will </strong>(e. Great Challenger), som för årsdebut tillsammans med Ken Ecce. Hästen var finalist i både Kriteriet och Derby i hemlandet och har tagit sin största seger i fyraåringsloppet Aalborg Stora Pris.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/04/240426.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">4Det rids dubbla semi classique-lopp på Vincennes (första start kl. 16.03) denna fredag, men varken i Prix Rene Palyart (€120.000) för fyraåringar eller Prix Louis Fornical (€120.000) för femåringar går det skönja svenska inslag.</p>



<p>Blågula hopp finns däremot i två andra lopp. Prix Sirone (€49.000) för sex- till åttaåriga hingstar och valacker som högst tjänat 135.000 euro innehåller Daniel Wäjersten-tränade <strong>Chitchat</strong> (e. Maharajah), Jörgen Westholms <strong>Ninepoints Lasse</strong> (e. Uncle Lasse), Laurent Claude Abrivards <strong>Invader Am</strong> (e. Muscle Hill), Marie Goetz <strong>Lucky Guy Boko </strong>(e. Broadway Hall) och Christoffer Erikssons <strong>Django Silver</strong> (e. Django Riff).</p>



<p>Prix de Villecresnes (€49.000) har en identisk proposition bortsett från att loppet är för ston.<br>Där startar Björn Goops italienska <strong>Buena Suerte Bi</strong> (e. Yankee Glide) mot tre svenskfödda ston i form av Pierre Levesques <strong>Iliade</strong> (e. Varenne), Jean Charles Pitons <strong>Musett af Djupmyra</strong> (e. Super Photo Kosmos) och Loris Ferros <strong>Maggiore</strong> (e. Googoo Gaagaa).</p>



<p>Två svenskfödda hästar från David Ciniers så blågulpräglade stallet kommer därtill att starta i Marseille Borely (första start kl. 11.35).<br><strong>Hattusa </strong>(e. Timoko) kommer ut i Prix du Jardin de la Magalone (€27.000) och <strong>Digital Indy </strong>(e. Super Photo Kosmos) luftas i Prix du Jardin Chanot (€27.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-04-26/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5På tal om just David Cinier så har han stärkt upp med ytterligare en svenskfödd häst i sitt stall då han numera har <strong>M.T.Oberon</strong> (e. Love You) 1.12,2am/1.096.393 kr på sin träningslista.</p>



<p>I Johan Untersteiner och Petri Salmelas regi räknade hästen hem 16 segrar på 68 starter bland vilka en V75-triumf värd 100.000 kronor på Umåker under juldagen år 2022 var den mest penningstinna.</p>



<p>M.T.Oberon såldes på Travera-auktion i slutet av mars för 140.000 kronor och än mer – 200.000 kronor – lade Annamari Sipilä upp för att köpa den svenskfödda treårsdamen <strong>Global Freedom</strong> (e. Face Time Bourbon) 1.17,8m/15.000 kr en vecka senare.</p>



<p>Efter att inlett med en andraplats för sin tränare Daniel Wäjersten i tävlingsdebuten den 21 mars så har nu Vermoproffset Henna Halme tagit över träningen av hästen.</p>



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



<p class="has-drop-cap">6Iika Nurmonens svenskfödde sjuåring <strong>Kurri Jari Boko</strong> (e. Make It Happen) 1.10,2ak/€181.771 har blivit den nionde hästen att få inbjuden till Finlandia Ajo (€190.000) som avgörs nästa söndag på Vermo.<br>Kurri Jari Boko kommer närmast från seger i Etain Royal Stayer (€22.000) och har under vintern även räknat hem Arctic King Heat (€15.400).</p>



<p>Det Grupp I-klassade loppet lockar även med en direktplats till Elitloppet och innehåller nu sex svenskfödda hästar.</p>



<p><strong>Inbjudna till Finlandia-Ajo</strong> (€190.000)<br><em>1.620 meter, autostart.</em></p>



<ul class="wp-block-list">
<li><strong>Hail Mary</strong> (e. Googoo Gaagaa) – Daniel Redén</li>



<li><strong>Stoletheshow </strong>(e. Dream Vacation) – Frode Hamre</li>



<li><strong>Vivid Wise As</strong> (e. Yankee Glide) – Alessandro Gocciadoro</li>



<li><strong>Global Withdrawl</strong> (e. S.J.’s Caviar) – Matias Salo</li>



<li><strong>Staro Mack Crowe</strong> (e. Bold Eagle) – Katja Melkko</li>



<li><strong>Betting Pacer </strong>(e. Maharajah) – Björn Goop</li>



<li><strong>Danao Degli Dei</strong> (e. Mago d’Amore) – Adrian Kolgjini</li>



<li><strong>Borups Victory</strong> (e. Googoo Gaagaa) – Daniel Wäjerstein</li>



<li><strong>Dozen of Oysters</strong> (e. Zola Boko) – Antti Ojanperä</li>



<li><strong>Kurri Jari Boko</strong> (e. Make It Happen) – Iikka Nurmonen</li>
</ul>



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



<p class="has-drop-cap">7Idag avgörs två uttagningslopp till Breeders Course på Victoria Park-banan i Wolvega varifrån de två främsta i respektive försökslopp tar sig vidare till finalerna på Solvalla söndag den 26 maj.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/2omertaboko-617x333.jpg" alt="" class="wp-image-563935"/><figcaption class="wp-element-caption">Omerta Boko vann tillsammans med sin tränare Michel F Rothengatter. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Där står en miljon kronor på spel till vinnaren av respektive klass och startfälten i Wolvega är mycket starka.<br>Bland deltagarna i klassen för hingstar och valacker syns <strong>Omerta Boko </strong>(e. Face Time Bourbon) som närmast kommer från seger i en etapp av Margaretas Tidiga Unghästserie på Solvalla.</p>



<p><strong>Breeders Course</strong> (€11.000), Treåriga hingstar/valacker.<br><em>2.100 meter, autostart.</em></p>



<ol class="wp-block-list">
<li><strong>Otis Dream </strong>(e. Broadway Fortuna) – Dion Tesselaar</li>



<li><strong>Ojuul Hazelaar </strong>(e. Hans Hazelaar) – Jim Veldman</li>



<li><strong>Fawaz Mi A </strong>(e. Gu d’Heripre) – Jaap van Rijn</li>



<li><strong>Odyssey Boko</strong> (e. E L Titan) – Hugo Langeweg Jr.</li>



<li><strong>Feldenkrais Pal</strong> (e. Trixton) – Robin Bakker</li>



<li><strong>Onana Boko </strong>(e. Trixton) – Jeffrey Mieras</li>



<li><strong>Omerta Boko</strong> (e. Face Time Bourbon) – Michel Rothengatter</li>



<li><strong>Orion Drago </strong>(e. International Moni) – Micha Brouwer</li>
</ol>



<p><strong>Breeders Course </strong>(€11.000), Treåriga ston.<br><em>2.100 meter, autostart.</em></p>



<p></p>



<ol class="wp-block-list">
<li><strong>Oriana Boko</strong> (e. Father Patrick) – Danny Brouwer</li>



<li><strong>Olivia Hazelaar </strong>(e. Hans Hazelaar) – Dion Tesselaar</li>



<li><strong>Onmyway Fortuna </strong>(e. Propulsio) – Micha Brouwer</li>



<li><strong>Freccia</strong> (e. International Moni) – Andrea Guzzinati</li>



<li><strong>O’ Hara Boko</strong> (e. Robert Bi) – Robin Bakker</li>



<li><strong>Olivia Bourbon</strong> (e. Face Time Bourbon) – Jaap van Rijn</li>



<li><strong>Orient Newport</strong> (e. Uncle Peter) – Jeffrey Mearas</li>



<li><strong>Figurati</strong> (e. Tactical Landing) – Jean-Pierre Dubois</li>
</ol>
