
<p class="has-drop-cap wp-block-paragraph">Traditionell Axevallahelg och lördagsomgången brukar bjuda på fin utdelning med minst ett par skrällar på vägen.</p>



<p class="wp-block-paragraph">Vi väljer ändå att bara spela med en spik – <strong>Nugget Zon</strong> i den avslutande avdelningen. Vi tycker han tävlar i lite för låg klass i förhållande till grundkapacitet och hoppas han kommer till ledningen. Då ska det vara bra segerchans.</p>



<p class="wp-block-paragraph">Vi börjar omgången med att ”gå kort” på tvåa hästar i de båda inledande avdelningarna. Detta innebär att vi har löst tre avdelningar på fyra rader. Då finns utrymme till bred gardering i några andra lopp och det kan behövas. Särskilt lärlingsloppet (V75-4) känns vidöppet. Vi har en rolig tipsetta i form av <strong>Gilmore Trot</strong>, men det känns lite som att vem som helst kan sticka nosen först. Öppet även i den sjätte avdelningen. Där kan det dessutom komma att gå undan rejält från början. Något som skulle gynna vår lite bortglömda tipsetta <strong>Räser Helge</strong> som gjort två starter efter skada och nu ska tävla i jänkarvagn för första gången.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/07/22v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Axevalla.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-07-22_8_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-07-22_8_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-07-22_8_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Klass II, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>It´s Peppertime </strong>är en tuffing som galopperade direkt från start i lördags. Om vi ser det som ett olycksfall i arbetet, så har insatserna innan dess varit av det positiva slaget. På Rättvik under midsommarhelgen spurtade han bra i ett Breeders Crown-försök bakom Game Brodde. Långt upplopp och lång distans gynnar fyraåringen.</li>



<li><strong>Keep Gamble </strong>blir favorit och det är väl egentligen inga fel med det. Han vann över lång distans senast och ser allt bättre ut för varje start. Om man däremot tar fram luppen och börjar leta efter frågetecken så konstaterar vi att hästen har startat med volt två gånger och galopperat vid båda tillfällena (plus kvalloppet där det också blev galopp). När det blir spel på över hälften av insatserna så gillas inte den statistiken riktigt.</li>



<li><strong>Wittgenstein </strong>inledde med fem raka innan han senast åkte på första förlusten. Då satt han dock långt ner i kön och det var inga fel på avslutningen i vida spår runt sista sväng. Lite frågetecken för spår fyra i volt, men känslan är att han bör klara det. Visade i årsdebuten näst senast att lång distans inte är några konstigheter.</li>



<li><strong>Västerbo Blizzard </strong>blev det fel för senast, så den starten glömmer vi. Han har gått iväg från småluriga spår i volt tidigare och dessutom vunnit över 2640 m. Fyraåringen bör stå sig bra i klassen och bevakas.</li>



<li><strong>San Sebastian </strong>tycker vi utvecklas på bra sätt och det ska vara en häst som står sig fint i lägsta STL-klassen. Plus för den långa distansen, men däremot är vi inte säkra på hur snabbt han kommer iväg från innern.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 11-3 B: 4-5-1-2-7-8 C: 6-10-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Från springspår känns <strong>R.K.Star</strong> spetsaktuell för Goop, men frågan är sedan om man väljer att köra där då formen, åtminstone från sidan, är ett frågetecken? <strong>Putte</strong> verkar inte ha några problem med snäva spår och Svanstedt kan nog tänka sig offensivt på hemmaplan.</p>



<h2 class="wp-block-heading">Avd 2 – Silverdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Natorp Bo </strong>ger ett grymt formintryck för dagen och här tycker vi att uppgiften känns lämplig. Han står fint inne i silverdivisionen och har ett perfekt läge bakom bilen, till skillnad från i de två senaste loppen då han haft spår elva respektive tolv. Slutrundan senast avverkades strax under 1.10 ute i spåren och då han hann fram till tredjeplatsen. Nu tror vi det är dags för seger igen.</li>



<li><strong>Blumen Indal </strong>kom helt fel på det senast då han blev över i tredjespår utan att komma ner någonstans. Vi drar ett streck över det loppet och konstaterar att han visade sin kapacitet då han vann V75-lopp i överlägsen still på Gävle i maj. Bombade då fram utvändigt om ledaren och var bara bäst. Gör han om den insatsen så utmanar han vår tipsetta.</li>



<li><strong>Behind Bars </strong>stämde det lite bättre för senast än i starterna innan. Fick ett fint lopp i rygg på ledaren och det var väl inte helt slutsålt i mål. Passande läge då han är snabb från start. Väljer man att gardera loppet vidare ska han absolut streckas.</li>



<li><strong>Charliebrown Effe </strong>vann 10 av 14 starter i fjol och tjänade drygt 1,2 miljoner. I år har sifforna inte alls sett lika bra ut, men inför den här starten låter det lite uppåt från stallhåll och dessutom sitter Calle Jepson upp bakom femåringen igen – de brukar trivas bra tillsammans. Med lite för hög fart i täten fäller man många.</li>



<li><strong>Mr Mah Can </strong>hade vi nog plockat med från ett bättre startspår. Han fick luckan för sent på Årjäng i lördags och det var inte tomt på krafter i mål. Formen sitter där och vi blir inte förvånade om han blåser ner många även den här gången.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 2-4 B: 3-11-12-9-1-5 C: 6-10-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Fina lägen för två snabba hästar i form av <strong>Natorp Bo</strong> och <strong>Behind Bars</strong>. Väljer man laddning med den förstnämnda tror vi han är snabb nog att svara ut de övriga. Vi bygger tipset på det resonemanget.</p>



<h2 class="wp-block-heading">Avd 3 – Gulddivisionen, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Emoji </strong>skulle upp till Gävle den 20 maj och fixa en biljett till Elitloppet, det blev galopp. Han omgavs senast av positiva rapporter inför storloppet på Jarlsberg, det blev galopp. Ändå lägger vi honom överst i rankingen då intrycket vid de båda segrarna där emellan på hemmaplan varit finfint. Flemming byter huvudlag på honom till den här starten och felfri är det bra chans.</li>



<li><strong>Rackham </strong>hade varit borta en månad innan loppet på Solänget senast. Med knappa varvet kvar till mål kom han fram utvändigt om ledaren (Admiral As) och vi tycker han höll bra. Nu blir det lite mer lämpligt intervall mellan starterna och även om det är gulddivisionen så är känslan att han möter mer passande motstånd än på slutet.</li>



<li><strong>Kentucky River </strong>höll strålande som tvåa i Harper Hanovers Lopp senast. Har pustat efter det och även om tränare Nordström låter helnöjd så är det kanske inte den där riktiga toppformen hos hästen. När han då sedan drog bricka åtta också i gulddebuten så åker han ner något hack i rankingen.</li>



<li><strong>Dats So Cool </strong>lyfter vi istället upp lite i ranking, självklart med tanke på det fina utgångsläget. Han kan öppna bra och lär få en fin resa från spår ett. Formen känns stabil och det här är en typisk häst som inte blir frånsprungen i något sällskap. Kan skrälla till med maxklaff.</li>



<li><strong>Revelation </strong>kommer säkert att bli en hel del spelad och betrodd – som vanligt. Efter två inledande galopper i år, då han inte alls såg bra ut, kunde man skönja en förbättring senast. Kapacitet för seger en bra dag, men enligt vårt tycke är det för många ”om och men” för att rankingen ska bli högre.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 6-2-8 <strong>B: </strong>1-7 <strong>C: </strong>3-4-5-9-10-11</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Här lär flera vilja vara med och köra för fina positioner. <strong>Dats So Cool</strong> är inte oäven från start, men visst släpper man? <strong>Emoji</strong> har krånglat en del bakom bilen i år, men är normalt sett snabb. Dessutom kan <strong>Rackham</strong> öppna bättre än vad man tror.</p>



<h2 class="wp-block-heading">Avd 4 – Lärlingslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Gilmore Trot </strong>är en rolig tipsidé i ett vidöppet lopp där det kan skrälla. Det hörs på Troels Andersen att han gillar den här hästen och insatsen vid årsdebuten för tre starter sedan var rejäl. Gången efter var han inte lika bra, men man var då inne på att han hade fått i sig för lite vätska. Störd till galopp senast, men såg annars laddad och fin ut. Med rätt smygare kan det gå och spelarna verkar tappa bort honom helt.</li>



<li><strong>Smajlis </strong>galopperade till slut i comebacken senast, men fick en genomkörare och här är man ute efter ledningen. Det pratas om rycktussar för första gången och den här är inte alls så tokig. Kommer man till spets och får bestämma en bit så kan det hålla hela vägen. Även han alldeles för lite spelad på V75.</li>



<li><strong>Hollywood Stone </strong>blev fast i rygg på ledaren senast och gick i mål med en hel del krafter sparade. Läget nu är fint, men kusken rätt orutinerad i de här sammanhangen. Om allt stämmer på vägen lär man vara med i segerstriden.</li>



<li><strong>Theycallmesixten </strong>var inte långt ifrån att ställa till med en riktig storskräll senast på Halmstad. Nu är det voltstart, vilket innebär att man får lov att ”växla ner” från bike till vanlig sulky. Ändå känns formen så pass bra att han bör streckas tidigt.</li>



<li><strong>Summerrazz </strong>har gjort tre lopp i ny regi. Galopp i de två första följdes upp av en säker seger senast. Vi har en känsla av att den här hästen är under fin utveckling och han bör passas tidigt från fint läge.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 8-6-3-10 <strong>B: </strong>1-7-13-9-15-12-4-11-14-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Summerrazz</strong> har tidigare visat sig kunna öppna bra från innerspår i volt och lär prova. Vi är lite inne på att <strong>Smajlis</strong> gärna skulle vilja ta sig till ledningen för att sedan köras där. Prickar Strandberg från springspår kan det gå vägen.</p>



<h2 class="wp-block-heading">Avd 5 – Diamantstoet, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Celiaz </strong>har gjort fyra starter på svensk mark och varit bra vid samtliga tillfällen. Nu har hon visserligen bakspår, men det klassiska ”långa upploppet” på Axevalla talar till hennes fördel. Hon klev undan på ett bra sätt från ledningen senast, men hanterar alla typer av upplägg på ett bra sätt. Vi noterar även att hon var före det här loppets troliga favorit Ivanka Amok i mål då de möttes på Solvalla 21/6, dessutom var hon mer betrodd.</li>



<li><strong>Ivanka Amok </strong>närmar sig årets första seger och den kan absolut komma här. Hon hade kopplat segergreppet mitt på upploppet via en rejäl långspurt senast, men fick sedan se sig knappt avslagen av Olga Utca. Full laddning att vänta från innerspår här och det finns på kartan att man håller upp ledningen.</li>



<li><strong>Nanny´s Girl </strong>är vi lite förtjusta i och när hon får sitt lopp kan hon vara i segerstriden i de flesta gäng. Senast blev det lite fel då kusken valde att sitta kvar när det kördes bakifrån. Resultatet blev istället att man fick ut för att runda den berömda korvkiosken i sista sväng. Det norska huvudlaget drogs inte förrän väldigt sent och med lite bättre klaff den här gången kan hon slå till.</li>



<li><strong>Kia Ora </strong>hade inte sin bästa dag senast och det visade sig efter loppet att hon både hade lite dåliga blodvärden och var lite klen i halsen. Nu återkommer hon efter paus och det är knappast toppform direkt. Snabb från start är hon, men mellan raderna låter det på tränare Kylin Blom att man kan tänka sig en ryggresa. Vi nöjer oss med tre streck, men Kia Ora ska med om man garderar vidare.</li>



<li><strong>La Sassicaia </strong>löper jämnt och bra hela tiden. Inför senast hade det blivit lite väl långt mellan starterna och vi är inne på att hon kommer vara lite vassare den här gången. Från ett bra läge är hon värd att se upp med.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 11-1-4 B: 5-2-7-10-8-3 C: 6-9-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Om Kylin Blom vill och vässar upp <strong>Kia Ora </strong>så lär hon spetsa. Nu sprang hon sig rejält trött i ledningen näst senast och var sjuk senast, så frågan är hur mycket man vill spänna bågen? Tar man det lugnt lär <strong>Ivanka Amok</strong> ha bra chans att försvara sitt innerspår.</p>



<h2 class="wp-block-heading">Avd 6 – Klass I, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Räser Helge </strong>är en intressant tipsetta och vi bygger det hela på att vi tror på en snabb inledning av loppet, vilket öppnar upp det för bakspårshästarna. ”Helge” har kommit tillbaka efter skada och åttaåringen bör fortsatt ha en del att hämta på tävlingsbanan. Nu blir det första gången med jänkarvagn och dessutom hoppar Magnus Djuse upp i sulkyn igen.</li>



<li><strong>Frazze </strong>är en effektiv spetshäst som vann V75-lopp på Klosterskogen just från ledningen under påskhelgen. Riskerar att åka på svar invändigt den här gången, vilket kan komma att kosta en allt för tuff inledning. Skulle man enkelt nå tät och sedan få bestämma en bit är det en bra segerchans.</li>



<li><strong>Edelweiss </strong>har utvecklats på ett strålande sätt i år och inte varit sämre än trea på sina sju starter. Senast var han tvåa i ett Breeders Crown-försök för de fyraåriga hästarna och siktet är så småningom inställt mot Derbykval. Då ska han räknas tidigt i ett V75-lopp i den näst lägsta klassen, särskilt då läget är bra och han kan öppna snabbt.</li>



<li><strong>Judge D. </strong>kan vara farlig att glömma bort. Galopperade dubbelt senast och har efter det fått en liten pust. Hästen vann V75-lopp i mars och vi noterar även att tre av hans fem triumfer i karriären har kommit just på Axevalla.</li>



<li><strong>Kaxig In </strong>blandar och ger lite i sina prestationer, men i grund och botten handlar det om en rejäl fyraåring som man väntar på att det ska lossna ordentligt för. Här blev väl läget lite väl långt ut för att man ska vara helt nöjd, men löper han upp till rykte och kapacitet kan det gå vägen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 11-5-3-2 B: 7-9-1-6-10-4 C: 12-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Här kan det komma att gå undan med många snabba. <strong>Herina Sotto</strong> från innern laddas, detsamma gäller säkert <strong>Edelweiss</strong>, <strong>Denco´s Rioja</strong> och <strong>Frazze</strong>. Summan av den kardemumman blir att vi tror mest på Frazze i tät in i första sväng.</p>



<h2 class="wp-block-heading">Avd 7 – Bronsdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Nugget Zon </strong>blir “badkarsvinnaren” i sista avdelningen då vi är inne på att det ändå är han som – bland flera startsnabba – tar hand om ledningen. Den positionen trivs han utmärkt i och den korta distansen är ytterligare något vi lägger till pluskontot. Femåringen tog sin första seger för året senast och vi har känslan av att han är på väg tillbaka till då han var som bäst som fyraåring i fjol. Till exempel som då han på Solvalla i september vann ett uttagningslopp till Europaderbyt just från ledningen.</li>



<li><strong>Lozano Di Quattro </strong>har alltid varit lovande och bra. Ändå är intrycket att han höjt sig ytterligare något snäpp de senaste månaderna med lite tuffare träningsupplägg. Han spetsade från spår ett på Solvalla näst senast och samma läge på Axevalla är jämförelsevis lite bättre. Det lär bli full gas från start och skulle man lyckas svara ut vår tipsetta är såklart mycket vunnet.</li>



<li><strong>Doge As </strong>fungerade inte i travet på Bjerke, men höll ihop det och var ändå tvåa. Nu har han fått träna på en dryg månad för Gocciadoro och ska bli intressant att se här. Läget i sig tror vi inte spelar så stor roll och om han bara fungerar lär han fälla många.</li>



<li><strong>Draupner </strong>fick utdelning på sin långa och fina form senast. Trots att han tog en kort startgalopp kunde Jesper Rydberg hitta andra par utvändigt och vinna enkelt. Hästen är kvar i bronsdivisionen och fick åter ett bra läge. Dock är vår känsla att det här loppet är lite tuffare än det på Halmstad senast.</li>



<li><strong>Eddie The Eagle </strong>har haft lite svårt att räcka på svensk mark tidigare, men nu är nog formen lite bättre och läget över kort distans är perfekt för en startsnabb häst. Vi vill dock se honom vinna en svensk bronsdivision innan vi höjer honom till skyarna.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 5 B: 1-10-2-3-9-6-4 C: 7-11-8-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Lozano Di Quattro</strong> spetsade från bricka ett på Solvalla senast, om än med nöd och näppe. Här tror vi han kan få lite bekymmer med såväl <strong>Eddie The Eagle </strong>som mycket snabba <strong>Nugget Zon</strong>.</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">
									V75-FÖRSLAGET 22 JULI								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>Avd 1:</strong> 3,11 (4,5)<br /><strong>Avd 2:</strong> 2,4 (3,11)<br /><strong>Avd 3:</strong> 2,6,8 (1,7)<br /><strong>Avd 4:</strong> 1,3,4,5,6,7,8,9,10,11,12,13,14,15 (8,6)<br /><strong>Avd 5:</strong> 1,4,11 (5,2)<br /><strong>Avd 6:</strong> 1,2,3,5,6,7,9,11 (10,4)<br /><strong>Avd 7:</strong> 5 Nugget Zon (1,10)</p>
<p class="wp-block-paragraph"><em>4.032 rader / 2.016 kronor</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
