
<p class="has-drop-cap">1Från Umåker till Elitloppet? Den vägen tog exempelvis <strong>Borups Victory</strong> (e. Googoo Gaagaa) förra året när han vann Guldbjörken som uppladdning inför Elitloppet, där det slutade med andraplatsen i finalen.<br>I eftermiddag (första start 14.45) är det dags för årets upplaga av Guldbjörken och Daniel Wäjersten har vunnit de två senaste upplagorna. <strong>Global Badman</strong> (e. Yield Boko) triumferade nämligen 2023.</p>



<p>Nu har han laddat med tre av nio deltagare, där tyske unghäststjärnan <strong>Gio Cash</strong> (e. Victor Gio) är det starkaste namnet. Hästen gjorde debut i Wäjerstens regi för 2,5 veckor sedan när han slutade tvåa – bakom Francesco Zet! – i första starten på elva månader. Sexåringen har vunnit 13 av 25 starter i karriären.<br>– Han har känts lite rullig i träningen. Senast hade han alldeles för tunga skor fram och barfota bak då, så det blev felbalanserat. Han tog några felsteg in i sista sväng och jag tror att det beror på det, för sedan travade han perfekt. Det blir lättare framskor och ett lopp i kroppen känns väldigt bra. Han kan lägga iväg bra för klassen från start, sade Daniel Wäjersten till V65 Direkt.</p>



<p><strong>Snabbaste vinnarna av Guldbjörken:</strong><br><em>År, vinnare (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2014 <strong>Hard Livin</strong> (e. S.J.’s Caviar) – Daniel Redén – 1.11,4a*</li>



<li>2019 <strong>Muscle Hustle</strong> (e. Muscle Mass) – Robert Bergh – 1.11,5a</li>



<li>2015 <strong>Nahar</strong> (e. Love You) – Roberg Bergh – 1.11,6a*</li>



<li>2018 <strong>Beau Mec</strong> (e. Jag de Bellouet) – Carl Johan Jepson (Lars Wikström) – 1.11,6a</li>



<li>2023 <strong>Global Badman</strong> (e. Yield Boko) – Daniel Wäjersten – 1.11,7a</li>



<li>2024 <strong>Borups Victory</strong> (e. Googoo Gaagaa) – Daniel Wäjersten – 1.11,7a</li>



<li>2022 <strong>Don Fanucci Zet</strong> (e. Hard Livin) – Örjan Kihlström (Daniel Redén) – 1.11,8a</li>



<li>2012 <strong>Sanity</strong> (e. Love You) – Johnny Takter (Malin Löfgren) – 1.11,9a</li>
</ul>



<p><em>*Hard Livin och Nahar tog sina segrar över kort distans, övriga vinnare över medeldistans.</em></p>



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



<p class="has-drop-cap">2Över 22 miljoner jackpotkronor extra ligger i sjurättspotten på V75 och Sulkysports expert har synas jackpotomgången noga. Det slutade med singelstreck i första och sista avdelningen på systemförslaget.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-spikarna-hittas-i-forsta-och-sista/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång med analyser, spikar, drag och systemförslag. </a></p>



<p>Ett av dessa är Daniel Redén-tränade <strong>Popeye Tooma</strong> (e. S.J.’s Caviar), som efter en fin sensommar och höst haft en skakig inledning på 2025, där han först ströks för en sårskada i mars och sedan galopperade i årsdebuten i april.<br>– Han har galopperat i konstigt läge två gånger i rad nu. Jag körde honom i jobb i måndags och han känns så jäkla fin så jag blir brydd om han gör likadant igen. Vi har även varit hos veterinären och kollat upp honom, men det var inga stora grejer. Vi kör som tidigare vad det gäller balansen och det känns bra, så jag hoppas att han hoppar tillbaka i gamla gängor igen. Det blir bike den här gången, säger Daniel Redén på Stall Zets hemsida.</p>



<p>Hos vår samarbetspartner Travnet finns andelar till dagens V75-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2025-05-10_27_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</a></p>



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



<p class="has-drop-cap">3Efter Umåkers tävlingar avrundas lördagskvällen med Rättvik (första start 18.50). Daniel Redén sänder sju hästar till Umåker, Björn Goop tre och Jörgen Westholm en häst. Medan Björn tar vägen till Västerbotten väljer Redén och Westholm för egen del Rättvik denna lördagskväll.</p>



<p>Trion har varsin, spännande häst i ett lopp stängt vid 130.000 kronor. Westholm mönstrar <strong>Okocha Boko</strong> (e. Raja Mirchi) som efter andraplatsen i debuten som treåring vunnit två av tre starter i år och fortfarand einte varit sämre än tvåa på fyra försök.<br>Goop sätte upp Peter Zadel bakom <strong>Magic Bourbon</strong> (e. Face Time Bourbon), som vann tre av fem starter förra året, men gjorde bort sig med galopp i årsdebuten. <br>Redén kör själv sitt bidrag <strong>Irwin Zet</strong> (e. Propulsion), som spräckt segernollan i år som fyraåring. Med valackens mamma <strong>Trinity Zet</strong> (e. S.J.’s Photo) har Redén tagit sin största seger som kusk – i finalen i Breeders Crown för fyraåriga ston 2015!</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/05/250510.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap">4Berit Tveter Alm är en av de största bland kvinnorna i den norska travhistorien. Idag hyllas 72-åringen på hemmabanan Biri med ett lopp som bär hennes namn.</p>



<p>Berit är själv på plats på Biri och har med sig silverpokaler från hennes egen framgångsrika kuskkarriär, som ska delas ut till vinnaren i hennes lopp. Berit Tveter Alms Äreslopp är utskrivet som silverdivisionsförsök, men öppet för ston som tjänat mer pengar. Två svenskfödda slåss om 100.000 kronor och silverpokalerna: <strong>Ninepoints Lover</strong> (e. Love Ypu) och <strong>My Dreams</strong> (e. Nuncio).</p>



<p>Berit Tveter Alm hade travsporten i bloden genom pappa Alf Tveter, som själv var tränare, och Berit vann sitt första lopp redan som 14-åring 1966. Drygt 50 år senare avslutade hon kuskkarriären 2017 efter att ha kört lopp varje år.<br>Vid sidan om tävlingsbanan var hon en av initiativtagarna till det norska damförbundet i travet, där hon dessutom satt som ordförande i 25 år. Hon var även högste boss i europeiska amatörernas organisation Fegat. </p>



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



<p class="has-drop-cap">5 Travera håller som vanligt auktion ikväll och det bjuds ut allt från betäckningar till fölston och starthästar på kvällens auktion. En som sticker ut är femårige valacken <strong>Safety Tile</strong> (e. International Moni-High Beam Hanover), 1.14,4am/196.854 kr, som vunnit fem av 21 lopp.</p>



<p>Mormor <strong>Her Culese </strong>(e. Muscles Yankee), 1.10,6<em>/</em>$354.658, är också mormor till självaste <strong>Jiggy Jog </strong>(e. Walner), 1.08,0ak/30.252.926 kr, som är det vinstrikaste svenskfödda stoet genom tiderna.</p>



<p><a href="https://www.travera.nu/kopa-hast/" data-type="link" data-id="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här hittar du hästarna som går under klubban.</a></p>



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



<p class="has-drop-cap">6 Blir det någon fransman från Prix des Ducs de Normandie (€150.000) som kommer till Elitloppet i år? Kandidater saknas knappast och den mest aktuella är förstås <strong>Hohneck </strong>(e. Royal Dream) som vann Elitloppet för två år sedan, men som ifjol fick nöja sig med en femteplats i finalen efter ha slutat tvåa i sitt försök.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/05/hohneck5-scaled.jpg" alt="" class="wp-image-443631"/><figcaption class="wp-element-caption">Hohneck (15) spurtar hem Prix des Ducs de Normandie för Gabriele Gelormini för två år sedan. Foto: Gerard Forni</figcaption></figure>



<p><strong>Prix des Ducs de Normandie</strong> (€150.000)<br>4-11 år.<br><strong>Priser: </strong>67.500-37.500-21.000-12.000-3.000-1.500 euro.<br><em>2.450 meter.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Idole of Love</strong> (e. Real de Lou) – Louis Baudouin</li>



<li><em>Cocquaholy – struken</em></li>



<li><strong>Ksar</strong> (e. Follow You) – Robin Lamy</li>



<li><strong>Iguski Sautonne </strong>(e. Village Mystic) – Matthieu Abrivard</li>



<li><strong>Jeroboam d’Erable</strong> (e. Prodigious) – David Thomain</li>



<li><strong>Ibiki de Houelle</strong> (e. Love You) – Eric Raffin</li>



<li><strong>Ino du Lupin </strong>(e. Scipion du Goutier) – Antoine Wiels</li>



<li><strong>Face Time</strong> (e. Coktail Jet) – Alexandre Abrivard</li>



<li><strong>It’s A Dollarmaker</strong> (e. Saxo de Vandel) – Benjamin Rochard</li>



<li><strong>Jean Balthazar</strong> (e. Alto de Viette) – Pascal Castel</li>



<li><strong>Emeraude des Bais</strong> (e. Repeat Love) – Franck Nivard</li>



<li><strong>Hohneck</strong> (e. Royal Dream) – Gabriele Gelormini</li>
</ol>



<p><a href="https://sulkysport.se/trav-och-galopp/caen-2025-05-10/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/caen-2025-05-10/">Här hittar du alla startlistor till Caens tävlingar. </a></p>



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



<p class="has-drop-cap">7 Från Wolvega till Solvalla. <strong>Pele Boko </strong>(e. Readly Express), vinnare av Svensk Uppfödningslöpning ifjol,  gör sin andra start ikväll på Victoria Park i Wolvega efter ha vunnit sin årsdebut – Prix Leo Schalkoort (€6.600) – den 25 april på samma bana</p>



<p>Då travade Erwin Bots på 1.15,5a/2.100 meter och sista halvvarvet travades efter 1.11,7. Ikväll handlar det om TCT Criterium der Driejarige (€15.400) för hingstar och valacker. Erwin Bot sköter själv om tömmarna i loppet med 7.000 euro i förstapris. </p>



<p><strong>TCT Criterium der Driejarige</strong> (€15.400)<br>Treåriga hingstar/valacker.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Moon Walker</strong> (e. Maharajah) – Thomas Panschow</li>



<li><strong>Malo Renka TF</strong> (e. Alto de Viette) – John Dekker</li>



<li><strong>Mink Boko TF</strong> (e. Helgafell) – Robin Bakker</li>



<li><strong>Pleasure Trans R</strong> (e. Brillantissime) – Micha Brouwer</li>



<li><strong>Pavarotti’s Wish </strong>(e. Offshore Dream) – Bas Crebas</li>



<li><strong>Pele Boko</strong> (e. Readly Express) – Erwin Bot</li>



<li><strong>Moni Making Pace </strong>(e. International Moni) – Dion Tesselaar</li>



<li><strong>Mad Max </strong>(e. Booster Winner) – Jim Veldman</li>
</ol>
