
<p class="has-drop-cap">1 Daniel Wäjerstens treåringar har visat hög klass under året, men än har inte hela stallets 2023:or visat upp sig på tävlingsbanan. Ikväll i Gävle (start 18.20) är det dags för debut för <strong>Midnight Million</strong> (e. Tactical Landing-Godiva Ås).</p>



<p>Av Daniel Wäjerstens 40 treåringar han för tillfället tränar har 37 startat (38 efter ikväll) och 32 vunnit lopp i hans regi i år. </p>



<p>Bäst bland hans treåringar så här långt är E3-tvåan <strong>Morning Rain</strong> (e. Face Time Bourbon) som efter fem starter har tre segrar, två andraplatser och 1.087.500 kronor på kontot.</p>



<p>Därefter följer <strong>Zarajevo Games</strong> (e. Calgary Games) med fem vinster på sex försök och 511.500 kronor insprunget. Trea på listan över de vinstrikaste treåringarna i Daniel Wäjerstens stall är <strong>Grace In Heaven</strong> (e. Chapter Seven) som vunnit tre av sju starter och tjänat 373.500 kronor.</p>



<p>Något fyraårigt sto som kunde vara med i Svensk Travsports Unghästserie hade inte Wäjersten denna kväll, men loppet som bara lockat fem hästar till start har ett par riktigt intressanta ston upp bakom bilen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/mycreationrnsadam-617x333.jpg" alt="" class="wp-image-766044"/><figcaption class="wp-element-caption">Katja Melkko-tränade My Creation och Rikard N Skoglund. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Katja Melkkos <strong>My Creation</strong> (e. Hohneck) sprang 1.10,0a/1.640 meter som trea i Fyraåringseliten för ston på Solvalla under Elitloppsdagen och gjorde en start till drygt två veckor senare där hon inte var till sin fördel. Knappt två månaders tävlingspaus har säkert gjort henne gott och hon börjar från spår fem.</p>



<p>Innanför sig, från spår två, har My Creation Katrin Fricks <strong>Brunet Garde</strong> (e. Power), som efter två raka segrar på Solvalla i vintras vilat från tävlandet och som idag gör comeback.</p>



<p>Efter sju raka vinster under 2026 bröts segerraden för Jasmine Isings montéspecialist <strong>Kingsman</strong> (e. Maharajah) på Färjestad den 21 juli. Ikväll tas kampen upp mot nya triumfer för den sjuårige valacken som i år sprungit in 317.500 på sina nio starter, där alla utom en gjorts under sadel.</p>



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



<p class="has-drop-cap">2 Claes Sjöström har ett klart grepp i championstriden på Gotland och tvåa ligger tränarkollegan från Solvalla, Daniel Redén och de båda är på plats i <strong>Visby</strong> (start 17.45) denna torsdag. Sjöström leder kuskligan på 17 segrar medan Redén har nio, en pinne före trean Martin Malmqvist.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/skarmavbild20260812kl.16.33.11-617x406.jpg" alt="" class="wp-image-885667"/><figcaption class="wp-element-caption">Claes Sjöström. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Idag sitter Claes Sjöström upp i åtta av nio lopp och visst ser det ut som att han ska kunna fylla på segerskörden på ön. I det inledande loppet sitter han upp bakom Susanne Nordbergs treåriga sto <strong>Fiona Findarve</strong> (e. Campo Bahia) som kvalade på 1.18,9/2.140 meter för tre veckor sedan</p>



<p>Bästa segerchansen för Claes Sjöström ser <strong>Global Good Luck </strong>(e. S.J.’s Caviar) ut att vara. Stoet har tre segrar på sju starter i år som fyraåring och i Visby trivs hon allra bäst. Sex starter har resulterat i fem vinster på Skrubbs.</p>



<p>Försprånget till Daniel Redén i kuskligan är betryggande, men det ser inte omöjligt ut för Redén att knappa in en eller ett par segrar på Claes Sjöström idag.</p>



<p>Årets Elitloppsvinnare börjar med att debutera treårige <strong>Snoop Doggie </strong>(e. Don Fanucci Zet) innan han sätter sig upp bakom Propulsion-dottern <strong>R.Coco</strong>, som inledde karriären med två raka segrar innan hon åkte på pumpen i Visby i senaste starten.</p>



<p>Hästägarepokalen 2026 med 40.000 kronor till vinnaren kan mycket väl gå till Daniel Redén. Delicious andra avkomma, treårige <strong>King Dee Zet</strong> (e. Hard Livin) gör fjärde starten i livet och är placerad på startvolten i ett lopp där tuffaste motbudet, Henrik Hoffmans <strong>Earl’s Black Son</strong> (e. Earl Simon) står med bakspår på tillägg.</p>



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



<p class="has-drop-cap">3 Först ut av landets banor är lunchbanan <strong>Skellefteå</strong> (start 12.20) där Kallsvenskans <strong>Hög Fara </strong>(e. Art Kjarvald) är på jakt efter årets sjätte seger i tionde starten. Hög Fara testade kval till Kriteriestoet på Dannero i senaste starten, men det slutade med galopp och det treåriga stoet, som möter äldre kallblod idag, är alltjämt obesegrat felfri. Jenny Engfors sitter upp i sulkyn idag.</p>



<p>Det äldre varmblodsgardet får slåss om ett förstapris på 40.000 kronor i ett lopp över medeldistans i Skellefteå där sex av de åtta startande hästar kan titulera sig miljonärer. Sandra Erikssons <strong>King of Djazz </strong>(e. Zola Boko) är rikast i fältet och står med 20 meters tillägg på bland andra Per Viklunds tysk <strong>Lozano </strong>(e. Love You), som tillsammans med King of Djazz och <strong>The Bald Eagle</strong> (e. Bold Eagle) är fältets enda hästar som lyckats vinna lopp under 2026.</p>



<p>Hemmatränaren Jerker Bjurmans framgångsrika sto <strong>Ängskalla</strong> (e. Skaffer Brunen), 1.23,9am/1.371.637 kr, har varit en plusvariant i avelsboxen sedan hon slutade tävla.</p>



<p>Varje år sedan 2018 har hon fått föl och det första, <strong>Mira Kiro</strong> (e. Bork Odin), 1.25,1ak/837.815 kr, vann sex lopp under karriären.<strong> Saga Kiro</strong> (e. Tekno Odin), 1.24,5m/672.800 kr, <strong>Opal Kiro</strong> (e. Ängsborken), 1.24,6ak/589.900 kr, <strong>Trollbalder </strong>(e. B.W.Modde), 1.26,6m/426.000 kr och fyraårige <strong>Bjarte Kiro</strong> (e. Bäcklös Uriel), 1.29,8k*/173.200 kr har sammanlagt vunnit 32 lopp och treårige <strong>Chili Kiro</strong> (e. Lome Brage), 1.34,9m*/50.000 kronor har hunnit vinna lopp hon också.</p>



<p>Idag kvalar Jerker Bjurman Ängskallas tvååriga avkomma <strong>Donna Kiro</strong> (e. Nordsjö Odin) på hemmabanan och det verkar som att trenden med startande avkommor fortsätter för den 19-åriga Ängskalla.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/08/260813.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/08/260813.pdf" target="_blank" rel="noreferrer noopener">Startlistorna till dagens tävlingar hittar du här.</a></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/08/skarmavbild20260812kl.20.46.44-617x648.jpg" alt="" class="wp-image-885697"/><figcaption class="wp-element-caption">Solvalla Yearling Sale firar tio år på Solvalla.</figcaption></figure>



<p class="has-drop-cap">4 Solvalla Yearling Sale hålls nästa tisdag på huvudstadsbanan och det finns fortfarande platser kvar på restaurang Kongressen. Katalogen innehåller 130 ettåringar och från klockan 10.00 på tisdag finns det möjlighet att inspektera ettåringarna på Solvallas stallbacke. Första utrop är klockan 18.00.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/08/solvallayearlingsale2026.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/08/solvallayearlingsale2026.pdf" target="_blank" rel="noreferrer noopener">I år firar Solvalla Yearling Sale tio år på Solvalla och auktionskatalogen kan laddas ner här.</a></p>



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



<p class="has-drop-cap">5 Sabine Kagebrant startar toppstammade <strong>Mana Mix </strong>(e. Hohneck-Anna Mix) i <a href="https://www.letrot.com/courses/2026-08-13/7502/6" data-type="link" data-id="https://www.letrot.com/courses/2026-08-13/7502/6" target="_blank" rel="noreferrer noopener">Prix d’Elancourt </a>(€40.000) för fyraåriga ston på Enghien (första start kl. 09.37) och Pierre-Yves Verva får chansen i sulkyn i loppet över 2.875 meter med 18.000 euro till vinnaren och där stoet jagar sin fjärde årsseger i femte starten. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260618kl.18.57.51-617x342.jpg" alt="" class="wp-image-864142"/><figcaption class="wp-element-caption">Mana Mix och Matthieu Abrivard.</figcaption></figure>



<p>Jarmo Niskanen tävlar också på Enghien och Murmure (e. Earl Simon) jagar första årssegern i <a href="https://www.letrot.com/courses/2026-08-13/7502/8" data-type="link" data-id="https://www.letrot.com/courses/2026-08-13/7502/8" target="_blank" rel="noreferrer noopener">Prix de la Porte du Pre-Saint-Gervais</a> (€35.000) i ett fyraåringslopp för hingstar/valacker över 2.150 meter (auto) och där uppgår förstapriset till 15.750 euro.</p>



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



<p class="has-drop-cap">6 Första försöket i Tour Europeen du Trotteur Francais – Prix de l’Amitie Franco Belgo (€25.000) – avgjordes i tisdags i Mons. Anthony Barrier guidade nioårige valacken <strong>Hamonet de Choisel</strong> (e. Vittel de Brevol) till seger på 1.11,9a/2.300 meter efter ha travat utan rygg större delen av loppet, medan både tvåan Jotunn du Dome (e. Seduissant) och trean Hannibal Tuilerie (e. Remember Jihem) noterade 1.12,0.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/08/skarmavbild20260812kl.12.09.02.png" alt="" class="wp-image-885436"/><figcaption class="wp-element-caption">Hamonet de Choisel tog över täten i sista sväng och vann i ohotad stil för Anthony Barrier. </figcaption></figure>



<p>För Sylvain Gérard Dupont-tränade Hamonet de Choisel var det andra raka segern och i starten innan tog han hem Prix de la Ville de Carentan Les Marais (€26.000) i Carentan.</p>



<p>Återstående försök i Tour Europeen du Trotteur Francaisför –öppet endast för franskregistrerade travare – avgörs i <strong>Wolvega</strong> (29 augusti), <strong>Avenches</strong> (12 september), <strong>Son Pardo </strong>(26 september), <strong>Gelsenkirchen </strong>(10 oktober), medan finalen hålls i<strong> Mons</strong> den 24 oktober.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/alessandrogocciadoro1-617x333.jpg" alt="" class="wp-image-564256"/><figcaption class="wp-element-caption">Alessandro Gocciadoro har sex hästar till start i ett Grupp I-lopp på lördag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">7 På lördag kväll avgörs Grupp I-klassade Gran Premio Citta di Montecatini (€132.000) i Montecatini med försök och final. En svenskfödd travare – <strong>Ziva</strong> (e. Varenne) – tar chansen och i sitt försök får stoet bland annat möta tidigare Stefan Melander-tränade <strong>Click Bait</strong> (e. Cantab Hall). De fyra främsta från varje försök går vidare till finalen (€100.980) plus den snabbaste femman.</p>



<p>Alessandro Gocciadoro har som vanligt laddat med flera travare och sex hästar selas ut från hans stall och förutom tidigare nämnda Click Bait och Ziva handlar det också om <strong>Caio Titus Bond</strong>, <strong>Dany Capar</strong>, <strong>Dolce Viky </strong>och <strong>Jimmy Ferro BR</strong>.</p>



<p><strong>Gran Premio Citta di Montecatini</strong> (€15.510) <strong>– försök I:</strong><br>Äldre hästar.<br><em>1.640 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Bleff Dipa </strong>(e. Mister J.P.) – Enrico Bellei</li>



<li><strong>Dany Capar</strong> (e. Exploit Caf) – Alessandro Gocciadoro</li>



<li><strong>Diamond Francis</strong> (e. Exploit Caf) – Andrea Farolfi</li>



<li><strong>Click Bait </strong>(e. Cantab Hall) – Antonio di Nardo</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Andrea Guzzinati</li>



<li><strong>Galileo Ferm</strong> (e. Maharajah) – Marco Stefani</li>



<li><strong>Ziva</strong> (e. Varenne) – Vincenzo P Dell’Annunziataiata</li>



<li><strong>Eminem Font </strong>(e. Ringostarr Treb) – Santo Mollo</li>



<li><strong>Dana Ek</strong> (e. Vivid Wise As) – Robero Vecchione</li>
</ol>



<p><strong>Försök II:</strong></p>



<ol class="wp-block-list">
<li><strong>Dolce Viky </strong>(e. Adrian Chip) – Andrea Guzzinati</li>



<li><strong>Ernesto Spritz</strong> (e. Maharajah) – Andrea Farolfi</li>



<li><strong>Jimmy Ferro BR </strong>(e. Love You) – Alessandro Gocciadoro</li>



<li><strong>Fenicia As </strong>(e. Readly Express) – Roberto Vecchione</li>



<li><strong>Dubhe Prav </strong>(e. Robert Bi) – Santo Mollo</li>



<li><strong>Epico Dell’Est </strong>(e. Exploit Caf) – Marcello di Nicola</li>



<li><strong>Finalmente Par</strong> (e. Varenne) – Antonio di Nardo</li>



<li><strong>Caio Titus Bond </strong>(e. Varenne) – Federico Esposito</li>



<li><strong>Ideal San Leandro</strong> (e. Timoko) – Vincenzo P Dell’Annunziataiata</li>
</ol>
